Open In App

Minimum count of numbers required from given array to represent S

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Share
Report issue
Report

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:
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 <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;
}


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<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 array
static int printAllSubsets(int arr[],
                           int n, int sum)
{
    ArrayList<Integer> 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




<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 S
function 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 array
function 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>


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 <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 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 Code
int main()
{
    int arr[] = { 9, 6, 5, 1 };
    int m = sizeof(arr) / sizeof(arr[0]);
    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




<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 sequence
function 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 Code
let arr = [ 9, 6, 5, 1 ];
let m = arr.length;
document.write(Count(arr, m, 11));
 
 
</script>


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

 Efficient Approach using O(N) space only:
We can use a DP array of size (N+1). Each of the indices(i) of DP array represents the minimum number of components required to build number i.
Now, at number i, if the efficient solution uses component c, then:
numComponents(i) = numComponents(i-c) + 1
We can use this relation to fill our DP array from left to right, and can get this working in O(M*N) time with O(N) space.

C++




#include<bits/stdc++.h>
using namespace std;
 
int findMinCountToReachSum(int sum, vector<int> components)
{
    // numWays[i] represent number of ways to build value i efficiently
    // using provided components.
    vector<int> numWays(sum + 1, INT_MAX - 1);
 
    // Base case: Number of ways to make sum 0 is 0.
    numWays[0] = 0;
 
    for (int i = 1; i <= sum; i++)
    {
        // Try to improve the value using given components.
        for (int j = 0; j < components.size(); j++)
        {
            // component c can only contribute to building number i if it is
            // less than or equal to number i.
            if (i >= components[j])
            {
                // Check if component c can be utilized to build number i in
                // a better way.
                numWays[i] = min(numWays[i], numWays[i - components[j]] + 1);
            }
        }
    }
 
    return (numWays[sum] == INT_MAX - 1) ? -1 : numWays[sum];
}
 
int main()
{
    int sum = 6;
    vector<int> arr = {2,1,4,3,5,6};
    cout << findMinCountToReachSum(sum, arr);
    return 0;
}


Java




import java.util.Arrays;
 
public class MinCountToReachSum {
 
    static int findMinCountToReachSum(int sum, int[] components) {
        int[] numWays = new int[sum + 1];
        Arrays.fill(numWays, Integer.MAX_VALUE - 1);
 
        // Base case: Number of ways to make sum 0 is 0.
        numWays[0] = 0;
 
        for (int i = 1; i <= sum; i++) {
            // Try to improve the value using given components.
            for (int j = 0; j < components.length; j++) {
                // component c can only contribute to building number i if it is
                // less than or equal to number i.
                if (i >= components[j]) {
                    // Check if component c can be utilized to build number i in
                    // a better way.
                    numWays[i] = Math.min(numWays[i], numWays[i - components[j]] + 1);
                }
            }
        }
 
        return (numWays[sum] == Integer.MAX_VALUE - 1) ? -1 : numWays[sum];
    }
 
    public static void main(String[] args) {
        int sum = 6;
        int[] arr = {2,1,4,3,5,6};
        System.out.println(findMinCountToReachSum(sum, arr));
    }
}


Python3




def find_min_count_to_reach_sum(sum, components):
    num_ways = [float('inf')] * (sum + 1)
    num_ways[0] = 0
 
    for i in range(1, sum + 1):
        for j in range(len(components)):
            if i >= components[j]:
                num_ways[i] = min(num_ways[i], num_ways[i - components[j]] + 1)
 
    return -1 if num_ways[sum] == float('inf') else num_ways[sum]
 
# Example usage
sum_value = 6
components_arr = [2,1,4,3,5,6]
result = find_min_count_to_reach_sum(sum_value, components_arr)
print(result)


C#




using System;
 
class Program
{
    static int FindMinCountToReachSum(int sum, int[] components)
    {
        int[] numWays = new int[sum + 1];
 
        for (int i = 1; i <= sum; i++)
        {
            numWays[i] = int.MaxValue; // Start with an invalid value.
             
            // Try to improve the value using given components.
            foreach (int component in components)
            {
                // A component can only contribute if it is less than or equal to the target value.
                if (i >= component && numWays[i - component] != int.MaxValue)
                {
                    // Check if the component can be utilized to build the target value in a better way.
                    numWays[i] = Math.Min(numWays[i], numWays[i - component] + 1);
                }
            }
        }
 
        return numWays[sum] == int.MaxValue ? -1 : numWays[sum];
    }
 
    static void Main()
    {
        int sum = 6;
        int[] arr = {2,1,4,3,5,6 };
 
        int result = FindMinCountToReachSum(sum, arr);
        Console.WriteLine(result);
    }
}


Javascript




function findMinCountToReachSum(sum, components) {
    const numWays = new Array(sum + 1).fill(Number.MAX_SAFE_INTEGER);
    numWays[0] = 0;
 
    for (let i = components[0]; i <= sum; i++) {
        for (let j = 0; j < components.length; j++) {
            if (i >= components[j]) {
                numWays[i] = Math.min(numWays[i], numWays[i - components[j]] + 1);
            }
        }
    }
 
    return numWays[sum] === Number.MAX_SAFE_INTEGER ? -1 : numWays[sum];
}
 
// Example usage
const sum = 6;
const arr = [2,1,4,3,5,6];
const result = findMinCountToReachSum(sum, arr);
console.log(result);


Output

1


Last Updated : 27 Dec, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads