Minimum count of numbers required from given array to represent S

25 May, 2021
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 Explanation: 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 implementation of the above approach: 
C++
Java
Python3
C#
Javascript
// C++ implementation 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 Sint 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 arrayint printAllSubsets(int arr[],                    int n, int sum){    vector<int> v;    return printAllSubsetsRec(arr, n,                            v, sum);} // Driver Codeint 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;}
// Java implementation to find the// minimum number of sequence// required from array such that// their sum is equal to given Simport java.util.*;import java.lang.*; class GFG{     // Function to find the// minimum elements required to// get the sum of given value Sstatic int printAllSubsetsRec(int arr[],                              int n,                              ArrayList<Integer> v,                              int sum){         // Condition if the    // sequence is found    if (sum == 0)    {        return (int)v.size();    }      if (sum < 0)        return Integer.MAX_VALUE;             // Condition when no    // such sequence found    if (n == 0)        return Integer.MAX_VALUE;      // 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.add(arr[n - 1]);         int y = printAllSubsetsRec(            arr, n, v,            sum - arr[n - 1]);    v.remove(v.size() - 1);         return Math.min(x, y);} // Function for every arraystatic int printAllSubsets(int arr[],                           int n, int sum){    ArrayList<Integer> v = new ArrayList<>();    return printAllSubsetsRec(arr, n,                              v, sum);} // Driver codepublic static void main(String[] args){    int arr[] = { 2, 1, 4, 3, 5, 6 };    int sum = 6;    int n = arr.length;         System.out.println(printAllSubsets(arr, n, sum));}} // This code is contributed by offbeat
# Python3 implementation to find the# minimum number of sequence# required from array such that# their sum is equal to given Simport sys # Function to find the# minimum elements required to# get the sum of given value Sdef printAllSubsetsRec(arr, n, v, Sum):         # Condition if the    # sequence is found    if (Sum == 0):        return len(v)     if (Sum < 0):        return sys.maxsize     # Condition when no    # such sequence found    if (n == 0):        return sys.maxsize     # Calling for without choosing    # the current index value    x = printAllSubsetsRec(arr, n - 1, v, Sum)     # Calling for after choosing    # the current index value    v.append(arr[n - 1])    y = printAllSubsetsRec(arr, n, v,                           Sum - arr[n - 1])    v.pop(len(v) - 1)     return min(x, y) # Function for every arraydef printAllSubsets(arr, n, Sum):         v = []    return printAllSubsetsRec(arr, n, v, Sum)     # Driver codearr = [ 2, 1, 4, 3, 5, 6 ]Sum = 6n = len(arr) print(printAllSubsets(arr, n, Sum)) # This code is contributed by avanitrachhadiya2155
// C# implementation to find the// minimum number of sequence// required from array such that// their sum is equal to given Susing System;using System.Collections.Generic; class GFG{     // Function to find the// minimum elements required to// get the sum of given value Sstatic int printAllSubsetsRec(int[] arr, int n,                            List<int> v, int sum){         // Condition if the    // sequence is found    if (sum == 0)    {        return v.Count;    }       if (sum < 0)        return Int32.MaxValue;              // Condition when no    // such sequence found    if (n == 0)        return Int32.MaxValue;       // 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.Add(arr[n - 1]);          int y = printAllSubsetsRec(arr, n, v,                               sum - arr[n - 1]);    v.RemoveAt(v.Count - 1);          return Math.Min(x, y);}  // Function for every arraystatic int printAllSubsets(int[] arr, int n,                           int sum){    List<int> v = new List<int>();    return printAllSubsetsRec(arr, n, v, sum);} // Driver code static void Main(){    int[] arr = { 2, 1, 4, 3, 5, 6 };    int sum = 6;    int n = arr.Length;     Console.WriteLine(printAllSubsets(arr, n, sum));}} // This code is contributed by divyeshrabadiya07
<script>// Javascript implementation to find the// minimum number of sequence// required from array such that// their sum is equal to given S // Function to find the// minimum elements required to// get the sum of given value Sfunction prletAllSubsetsRec(arr, n, v,                              sum){          // Condition if the    // sequence is found    if (sum == 0)    {        return v.length;    }       if (sum < 0)        return Number.MAX_VALUE;              // Condition when no    // such sequence found    if (n == 0)        return Number.MAX_VALUE;       // Calling for without choosing    // the current index value    let x = prletAllSubsetsRec(            arr,            n - 1, v, sum);       // Calling for after choosing    // the current index value    v.push(arr[n - 1]);          let y = prletAllSubsetsRec(            arr, n, v,            sum - arr[n - 1]);    v.pop(v.length - 1);          return Math.min(x, y);}  // Function for every arrayfunction prletAllSubsets(arr,                           n, sum){    let v = [];    return prletAllSubsetsRec(arr, n,                              v, sum);}  // Driver Code         let arr = [ 2, 1, 4, 3, 5, 6 ];    let sum = 6;    let n = arr.length;          document.write(prletAllSubsets(arr, n, sum));         </script>
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).
Efficient 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 implementation of the above approach:  
C++
Java
Python3
C#
Javascript
// C++ implementation 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 sequenceint Count(int S[], int m, int n){    vector<vector<int> > table(        m + 1,        vector<int>(            n + 1, 0));     // Loop to initialize 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 Codeint main(){    int arr[] = { 9, 6, 5, 1 };    int m = sizeof(arr) / sizeof(arr[0]);    cout << Count(arr, m, 11);    return 0;}
// Java implementation to find the// minimum number of sequence// required from array such that// their sum is equal to given Simport java.util.*; class GFG{ // Function to find the count of// minimum length of the sequencestatic int Count(int S[], int m, int n){    int [][]table = new int[m + 1][n + 1];     // Loop to initialize 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 Codepublic 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
# Python3 implementation 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 sequencedef Count(S, m, n):    table = [[0 for i in range(n + 1)]                for i in range(m + 1)]     # Loop to initialize 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 Codeif __name__ == '__main__':    arr= [9, 6, 5, 1]    m = len(arr)    print(Count(arr, m, 11)) # This code is contributed by Mohit Kumar
// C# implementation to find the// minimum number of sequence// required from array such that// their sum is equal to given Susing System; class GFG{ // Function to find the count of// minimum length of the sequencestatic int Count(int[] S, int m, int n){    int[,] table = new int[m + 1, n + 1];     // Loop to initialize 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 Codepublic 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
<script> // JavaScript implementation 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 sequencefunction Count(S, m, n){    let table = [];    for(let i = 0;i<m+1;i++){       table[i] = [];       for(let j = 0;j<n+1;j++){              table[i][j] = 0;       }    }     // Loop to initialize the array    // as infinite in the row 0    for (let i = 1; i <= n; i++) {        table[0][i] = Number.MAX_VALUE - 1;    }     // Loop to find the solution    // by pre-computation for the    // sequence    for (let i = 1; i <= m; i++) {         for (let 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 Codelet arr = [ 9, 6, 5, 1 ];let m = arr.length;document.write(Count(arr, m, 11));  </script>
2
 
Performance Analysis: 
Time Complexity: As in the above approach, there are two loop for the calculation 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).
 
mohit kumar 29
GauravRajput1
jrishabh99
offbeat
khushboogoyal499
divyeshrabadiya07
avanitrachhadiya2155
simmytarika5
Akanksha_Rai
splevel62
rohitsingh07052
Arrays
Backtracking
Dynamic Programming
Mathematical
Recursion
Arrays
Dynamic Programming
Mathematical
Recursion
Backtracking
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Multidimensional Arrays in Java
Linear Search
Given an array A[] and a number x, check for pair in A[] with sum as x (aka Two Sum)
Introduction to Arrays
Subset Sum Problem | DP-25
Write a program to print all permutations of a given string
Given an array A[] and a number x, check for pair in A[] with sum as x (aka Two Sum)
N Queen Problem | Backtracking-3
The Knight's tour problem | Backtracking-1
Backtracking | Introduction