# Minimum count of numbers required from given array to represent S

• Difficulty Level : Hard
• Last Updated : 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:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {25, 10, 5}, S = 30
Output:
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:
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++

 `// C++ implementation to find the``// minimum number of sequence``// required from array such that``// their sum is equal to given S` `#include ``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);``    ``cout << printAllSubsets(arr, n, sum)``        ``<< endl;``    ``return` `0;``}`

## Java

 `// Java implementation to find the``// minimum number of sequence``// required from array such that``// their sum is equal to given S``import` `java.util.*;``import` `java.lang.*;` `class` `GFG{``    ` `// Function to find the``// minimum elements required to``// get the sum of given value S``static` `int` `printAllSubsetsRec(``int` `arr[],``                              ``int` `n,``                              ``ArrayList 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 array``static` `int` `printAllSubsets(``int` `arr[],``                           ``int` `n, ``int` `sum)``{``    ``ArrayList v = ``new` `ArrayList<>();``    ``return` `printAllSubsetsRec(arr, n,``                              ``v, sum);``}` `// Driver code``public` `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

 `# Python3 implementation to find the``# minimum number of sequence``# required from array such that``# their sum is equal to given S``import` `sys` `# Function to find the``# minimum elements required to``# get the sum of given value S``def` `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 array``def` `printAllSubsets(arr, n, ``Sum``):``    ` `    ``v ``=` `[]``    ``return` `printAllSubsetsRec(arr, n, v, ``Sum``)``    ` `# Driver code``arr ``=` `[ ``2``, ``1``, ``4``, ``3``, ``5``, ``6` `]``Sum` `=` `6``n ``=` `len``(arr)` `print``(printAllSubsets(arr, n, ``Sum``))` `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# implementation to find the``// minimum number of sequence``// required from array such that``// their sum is equal to given S``using` `System;``using` `System.Collections.Generic;` `class` `GFG{``    ` `// Function to find the``// minimum elements required to``// get the sum of given value S``static` `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 array``static` `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`

## Javascript

 ``
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).

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++

 `// C++ implementation to find the``// minimum number of sequence``// required from array such that``// their sum is equal to given S` `#include ``using` `namespace` `std;` `// Function to find the count of``// minimum length of the sequence``int` `Count(``int` `S[], ``int` `m, ``int` `n)``{``    ``vector > 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[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);``    ``cout << Count(arr, m, 11);``    ``return` `0;``}`

## Java

 `// Java implementation 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 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 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`

## Python3

 `# 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 sequence``def` `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 Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr``=` `[``9``, ``6``, ``5``, ``1``]``    ``m ``=` `len``(arr)``    ``print``(Count(arr, m, ``11``))` `# This code is contributed by Mohit Kumar`

## C#

 `// C# implementation 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 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 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`

## Javascript

 ``
Output:
`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).

My Personal Notes arrow_drop_up