Minimum count of numbers required from given array to represent S
Last Updated :
27 Dec, 2023
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++
#include <bits/stdc++.h>
using namespace std;
int printAllSubsetsRec( int arr[],
int n,
vector< int > v,
int sum)
{
if (sum == 0) {
return ( int )v.size();
}
if (sum < 0)
return INT_MAX;
if (n == 0)
return INT_MAX;
int x = printAllSubsetsRec(
arr,
n - 1, v, sum);
v.push_back(arr[n - 1]);
int y = printAllSubsetsRec(
arr, n, v,
sum - arr[n - 1]);
return min(x, y);
}
int printAllSubsets( int arr[],
int n, int sum)
{
vector< int > v;
return printAllSubsetsRec(arr, n,
v, sum);
}
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
import java.util.*;
import java.lang.*;
class GFG{
static int printAllSubsetsRec( int arr[],
int n,
ArrayList<Integer> v,
int sum)
{
if (sum == 0 )
{
return ( int )v.size();
}
if (sum < 0 )
return Integer.MAX_VALUE;
if (n == 0 )
return Integer.MAX_VALUE;
int x = printAllSubsetsRec(
arr,
n - 1 , v, sum);
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);
}
static int printAllSubsets( int arr[],
int n, int sum)
{
ArrayList<Integer> v = new ArrayList<>();
return printAllSubsetsRec(arr, n,
v, sum);
}
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));
}
}
|
Python3
import sys
def printAllSubsetsRec(arr, n, v, Sum ):
if ( Sum = = 0 ):
return len (v)
if ( Sum < 0 ):
return sys.maxsize
if (n = = 0 ):
return sys.maxsize
x = printAllSubsetsRec(arr, n - 1 , v, Sum )
v.append(arr[n - 1 ])
y = printAllSubsetsRec(arr, n, v,
Sum - arr[n - 1 ])
v.pop( len (v) - 1 )
return min (x, y)
def printAllSubsets(arr, n, Sum ):
v = []
return printAllSubsetsRec(arr, n, v, Sum )
arr = [ 2 , 1 , 4 , 3 , 5 , 6 ]
Sum = 6
n = len (arr)
print (printAllSubsets(arr, n, Sum ))
|
C#
using System;
using System.Collections.Generic;
class GFG{
static int printAllSubsetsRec( int [] arr, int n,
List< int > v, int sum)
{
if (sum == 0)
{
return v.Count;
}
if (sum < 0)
return Int32.MaxValue;
if (n == 0)
return Int32.MaxValue;
int x = printAllSubsetsRec(arr, n - 1,
v, sum);
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);
}
static int printAllSubsets( int [] arr, int n,
int sum)
{
List< int > v = new List< int >();
return printAllSubsetsRec(arr, n, v, sum);
}
static void Main()
{
int [] arr = { 2, 1, 4, 3, 5, 6 };
int sum = 6;
int n = arr.Length;
Console.WriteLine(printAllSubsets(arr, n, sum));
}
}
|
Javascript
<script>
function prletAllSubsetsRec(arr, n, v,
sum)
{
if (sum == 0)
{
return v.length;
}
if (sum < 0)
return Number.MAX_VALUE;
if (n == 0)
return Number.MAX_VALUE;
let x = prletAllSubsetsRec(
arr,
n - 1, v, sum);
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 prletAllSubsets(arr,
n, sum)
{
let v = [];
return prletAllSubsetsRec(arr, n,
v, sum);
}
let arr = [ 2, 1, 4, 3, 5, 6 ];
let sum = 6;
let n = arr.length;
document.write(prletAllSubsets(arr, n, sum));
</script>
|
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++
#include <bits/stdc++.h>
using namespace std;
int Count( int S[], int m, int n)
{
vector<vector< int > > table(
m + 1,
vector< int >(
n + 1, 0));
for ( int i = 1; i <= n; i++) {
table[0][i] = INT_MAX - 1;
}
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 {
table[i][j]
= min(
table[i - 1][j],
table[i][j - S[i - 1]] + 1);
}
}
}
return table[m][n];
}
int main()
{
int arr[] = { 9, 6, 5, 1 };
int m = sizeof (arr) / sizeof (arr[0]);
cout << Count(arr, m, 11);
return 0;
}
|
Java
import java.util.*;
class GFG{
static int Count( int S[], int m, int n)
{
int [][]table = new int [m + 1 ][n + 1 ];
for ( int i = 1 ; i <= n; i++)
{
table[ 0 ][i] = Integer.MAX_VALUE - 1 ;
}
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
{
table[i][j] = Math.min(table[i - 1 ][j],
table[i][j - S[i - 1 ]] + 1 );
}
}
}
return table[m][n];
}
public static void main(String[] args)
{
int arr[] = { 9 , 6 , 5 , 1 };
int m = arr.length;
System.out.print(Count(arr, m, 11 ));
}
}
|
Python3
def Count(S, m, n):
table = [[ 0 for i in range (n + 1 )]
for i in range (m + 1 )]
for i in range ( 1 , n + 1 ):
table[ 0 ][i] = 10 * * 9 - 1
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 :
table[i][j] = min (table[i - 1 ][j],
table[i][j - S[i - 1 ]] + 1 )
return table[m][n]
if __name__ = = '__main__' :
arr = [ 9 , 6 , 5 , 1 ]
m = len (arr)
print (Count(arr, m, 11 ))
|
C#
using System;
class GFG{
static int Count( int [] S, int m, int n)
{
int [,] table = new int [m + 1, n + 1];
for ( int i = 1; i <= n; i++)
{
table[0, i] = int .MaxValue - 1;
}
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
{
table[i, j] = Math.Min(table[i - 1, j],
table[i, j - S[i - 1]] + 1);
}
}
}
return table[m, n];
}
public static void Main(String[] args)
{
int [] arr = { 9, 6, 5, 1 };
int m = 4;
Console.WriteLine(Count(arr, m, 11));
}
}
|
Javascript
<script>
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;
}
}
for (let i = 1; i <= n; i++) {
table[0][i] = Number.MAX_VALUE - 1;
}
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 {
table[i][j]
= Math.min(
table[i - 1][j],
table[i][j - S[i - 1]] + 1);
}
}
}
return table[m][n];
}
let arr = [ 9, 6, 5, 1 ];
let m = arr.length;
document.write(Count(arr, m, 11));
</script>
|
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)
{
vector< int > numWays(sum + 1, INT_MAX - 1);
numWays[0] = 0;
for ( int i = 1; i <= sum; i++)
{
for ( int j = 0; j < components.size(); j++)
{
if (i >= components[j])
{
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 );
numWays[ 0 ] = 0 ;
for ( int i = 1 ; i <= sum; i++) {
for ( int j = 0 ; j < components.length; j++) {
if (i >= components[j]) {
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 ]
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;
foreach ( int component in components)
{
if (i >= component && numWays[i - component] != int .MaxValue)
{
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];
}
const sum = 6;
const arr = [2,1,4,3,5,6];
const result = findMinCountToReachSum(sum, arr);
console.log(result);
|
Share your thoughts in the comments
Please Login to comment...