Minimum count of numbers required from given array to represent S

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

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

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