Minimum count of numbers required from given array to represent S

Given an integer S and an array arr[], the task is to find the minimum number of elements whose sum is S, such that any element of the array can be chosen any number of times to get sum S.

Examples:

Input: arr[] = {25, 10, 5}, S = 30
Output: 2
Explanation:
In the given array there are many possible solutions such as –
5 + 5 + 5 + 5 + 5 + 5 = 30, or
10 + 10 + 10 = 30, or
25 + 5 = 30
Hence, the minimum possible solution is 2

Input: arr[] = {2, 1, 4, 3, 5, 6}, Sum= 6
Output: 1
Explantion:
In the given array there are many possible solutions such as –
2 + 2 + 2 = 6, or
2 + 4 = 6, or
6 = 6,
Hence, the minimum possible solution is 1

Approach:
The idea is to find every possible sequence recursively such that their sum is equal to the given S and also keep track of the minimum sequence such that their sum is given S. In this way, the minimum possible solution can be calculated easily.



Below is the implmentation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implmentation to find the
// minimum number of sequence
// required from array such that
// their sum is equal to given S
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to find the
// minimum elements required to
// get the sum of given value S
int printAllSubsetsRec(int arr[],
                       int n,
                       vector<int> v,
                       int sum)
{
    // Condition if the
    // sequence is found
    if (sum == 0) {
        return (int)v.size();
    }
  
    if (sum < 0)
        return INT_MAX;
  
    // Condition when no
    // such sequence found
    if (n == 0)
        return INT_MAX;
  
    // Calling for without choosing
    // the current index value
    int x = printAllSubsetsRec(
        arr,
        n - 1, v, sum);
  
    // Calling for after choosing
    // the current index value
    v.push_back(arr[n - 1]);
    int y = printAllSubsetsRec(
        arr, n, v,
        sum - arr[n - 1]);
    return min(x, y);
}
  
// Function for every array
int printAllSubsets(int arr[],
                    int n, int sum)
{
    vector<int> v;
    return printAllSubsetsRec(arr, n,
                              v, sum);
}
  
// Driver Code
int main()
{
    int arr[] = { 2, 1, 4, 3, 5, 6 };
    int sum = 6;
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << printAllSubsets(arr, n, sum)
         << endl;
    return 0;
}

chevron_right


Output:

1

Performance Analysis:

  • Time Complexity: As in the above approach, there are two choose for every number in each step which takes O(2N) time, Hence the Time Complexity will be O(2N).
  • Space Complexity: As in the above approach, there is no extra space used, Hence the space complexity will be O(1).

Effiecient Approach: As in the above approach there is overlapping subproblems, So the idea is to use Dynamic Programming paradigm to solve this problem. Create a DP table of N * S to store the pre-computed answer for the previous sequence that is the minimum length sequence required to get the sum as S – arr[i] and in this way the finally after calculating for every value of the array, the answer to the problem will be dp[N][S], where m is the length of the array and S is the given sum.

Below is the implmentation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implmentation to find the
// minimum number of sequence
// required from array such that
// their sum is equal to given S
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to find the count of
// minimum length of the sequence
int Count(int S[], int m, int n)
{
    vector<vector<int> > table(
        m + 1,
        vector<int>(
            n + 1, 0));
  
    // Loop to intialize the array
    // as infinite in the row 0
    for (int i = 1; i <= n; i++) {
        table[0][i] = INT_MAX - 1;
    }
  
    // Loop to find the solution
    // by pre-computation for the
    // sequence
    for (int i = 1; i <= m; i++) {
  
        for (int j = 1; j <= n; j++) {
            if (S[i - 1] > j) {
                table[i][j]
                    = table[i - 1][j];
            }
            else {
  
                // Minimum possible
                // for the previous
                // minimum value
                // of the sequence
                table[i][j]
                    = min(
                        table[i - 1][j],
                        table[i][j - S[i - 1]] + 1);
            }
        }
    }
    return table[m][n];
}
  
// Driver Code
int main()
{
    int arr[] = { 9, 6, 5, 1 };
    int m = sizeof(arr) / sizeof(arr[0]);
    cout << Count(arr, m, 11);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implmentation to find the 
// minimum number of sequence 
// required from array such that 
// their sum is equal to given S 
import java.util.*; 
  
class GFG{ 
  
// Function to find the count of 
// minimum length of the sequence 
static int Count(int S[], int m, int n) 
    int [][]table = new int[m + 1][n + 1]; 
  
    // Loop to intialize the array 
    // as infinite in the row 0 
    for(int i = 1; i <= n; i++) 
    
    table[0][i] = Integer.MAX_VALUE - 1
    
  
    // Loop to find the solution 
    // by pre-computation for the 
    // sequence 
    for(int i = 1; i <= m; i++) 
    
    for(int j = 1; j <= n; j++) 
    
        if (S[i - 1] > j) 
        
            table[i][j] = table[i - 1][j]; 
        
        else
        
                  
            // Minimum possible for the 
            // previous minimum value 
            // of the sequence 
            table[i][j] = Math.min(table[i - 1][j], 
                            table[i][j - S[i - 1]] + 1); 
        
    
    
    return table[m][n]; 
  
// Driver Code 
public static void main(String[] args) 
    int arr[] = { 9, 6, 5, 1 }; 
    int m = arr.length; 
      
    System.out.print(Count(arr, m, 11)); 
  
// This code is contributed by gauravrajput1 

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implmentation to find the 
# minimum number of sequence 
# required from array such that 
# their sum is equal to given S 
  
# Function to find the count of 
# minimum length of the sequence 
def Count(S, m, n): 
    table = [[0 for i in range(n + 1)] 
                for i in range(m + 1)] 
  
    # Loop to intialize the array 
    # as infinite in the row 0 
    for i in range(1, n + 1): 
        table[0][i] = 10**9 - 1
  
    # Loop to find the solution 
    # by pre-computation for the 
    # sequence 
    for i in range(1, m + 1): 
  
        for j in range(1, n + 1): 
            if (S[i - 1] > j): 
                table[i][j] = table[i - 1][j] 
            else
  
                # Minimum possible 
                # for the previous 
                # minimum value 
                # of the sequence 
                table[i][j] = min(table[i - 1][j], 
                                table[i][j - S[i - 1]] + 1
  
    return table[m][n] 
  
# Driver Code 
if __name__ == '__main__'
    arr= [9, 6, 5, 1
    m = len(arr) 
    print(Count(arr, m, 11)) 
  
# This code is contributed by Mohit Kumar 

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implmentation to find the
// minimum number of sequence
// required from array such that
// their sum is equal to given S
using System;
  
class GFG{
  
// Function to find the count of
// minimum length of the sequence
static int Count(int[] S, int m, int n)
{
    int[,] table = new int[m + 1, n + 1];
  
    // Loop to intialize the array
    // as infinite in the row 0
    for(int i = 1; i <= n; i++) 
    {
       table[0, i] = int.MaxValue - 1;
    }
  
    // Loop to find the solution
    // by pre-computation for the
    // sequence
    for(int i = 1; i <= m; i++)
    {
       for(int j = 1; j <= n; j++) 
       {
          if (S[i - 1] > j)
          {
              table[i, j] = table[i - 1, j];
          }
          else
          {
                
              // Minimum possible for the
              // previous minimum value
              // of the sequence
              table[i, j] = Math.Min(table[i - 1, j],
                            table[i, j - S[i - 1]] + 1);
          }
       }
    }
    return table[m, n];
}
  
// Driver Code
public static void Main(String[] args)
{
    int[] arr = { 9, 6, 5, 1 };
    int m = 4;
  
    Console.WriteLine(Count(arr, m, 11));
}
}
  
// This code is contributed by jrishabh99

chevron_right


Output:

2

Performance Analysis:

  • Time Complexity: As in the above approach, there are two loop for the calulation of the minimum length sequence required which takes O(N2) time, Hence the Time Complexity will be O(N2).
  • Space Complexity: As in the above approach, there is a extra dp table used, Hence the space complexity will be O(N2).

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.