Generate a combination of minimum coins that sums to a given value

// C# program for 
// the above approach
using System;
using System.Collections.Generic;
class GFG{
  
static readonly int MAX = 100000;

// dp array to memoize the results
static int []dp = new int[MAX + 1];

// List to store the result
static List<int> denomination = 
            new List<int>();

// Function to find the minimum 
// number of coins to make the 
// sum equals to X
static int countMinCoins(int n, 
                         int []C, 
                         int m)
{
  // Base case
  if (n == 0) 
  {
    dp[0] = 0;
    return 0;
  }

  // If previously computed
  // subproblem occurred
  if (dp[n] != -1)
    return dp[n];

  // Initialize result
  int ret = int.MaxValue;

  // Try every coin that has smaller
  // value than n
  for (int i = 0; i < m; i++) 
  {
    if (C[i] <= n) 
    {
      int x = countMinCoins(n - C[i],
                            C, m);

      // Check for int.MaxValue to avoid
      // overflow and see if result
      // can be minimized
      if (x != int.MaxValue)
        ret = Math.Min(ret, 1 + x);
    }
  }

  // Memoizing value of current state
  dp[n] = ret;
  return ret;
}

// Function to find the possible
// combination of coins to make
// the sum equal to X
static void findSolution(int n, 
                         int []C, 
                         int m)
{
  // Base Case
  if (n == 0) 
  {
    // Print Solutions
    foreach (int it in denomination) 
    {
      Console.Write(it + " ");
    }
    return;
  }

  for (int i = 0; i < m; i++) 
  {
    // Try every coin that has
    // value smaller than n
    if (n - C[i] >= 0 && 
        dp[n - C[i]] + 1 == 
        dp[n]) 
    {
      // Add current denominations
      denomination.Add(C[i]);

      // Backtrack
      findSolution(n - C[i], C, m);
      break;
    }
  }
}

// Function to find the minimum
// combinations of coins for value X
static void countMinCoinsUtil(int X, 
                              int []C, 
                              int N)
{
  // Initialize dp with -1
  for (int i = 0; i < dp.Length; i++)
    dp[i] = -1;

  // Min coins
  int isPossible = countMinCoins(X, C, N);

  // If no solution exists
  if (isPossible == int.MaxValue) 
  {
    Console.Write("-1");
  }

  // Backtrack to find the solution
  else 
  {
    findSolution(X, C, N);
  }
}

// Driver code
public static void Main(String[] args)
{
  int X = 21;

  // Set of possible denominations
  int []arr = {2, 3, 4, 5};

  int N = arr.Length;

  // Function Call
  countMinCoinsUtil(X, arr, N);
}
}

// This code is contributed by shikhasingrajput 

using System;

class Program
{
    // Function to find the minimum number of coins to make the sum equals to X
    static int CountMinCoins(int X, int[] C, int N)
    {
        // dp array to store the minimum number of coins for each value from 0 to X
        int[] dp = new int[X + 1];

        // Initialize dp array
        dp[0] = 0;
        for (int i = 1; i <= X; i++)
        {
            dp[i] = int.MaxValue;
        }

        // Loop through all values from 1 to X and compute the minimum number of coins
        for (int i = 1; i <= X; i++)
        {
            for (int j = 0; j < N; j++)
            {
                if (C[j] <= i && dp[i - C[j]] != int.MaxValue)
                {
                    dp[i] = Math.Min(dp[i], 1 + dp[i - C[j]]);
                }
            }
        }

        // If no solution exists
        if (dp[X] == int.MaxValue)
        {
            Console.WriteLine("-1");
            return -1;
        }

        // Print the solution
        int k = X;
        while (k > 0)
        {
            for (int j = 0; j < N; j++)
            {
                if (k >= C[j] && dp[k - C[j]] == dp[k] - 1)
                {
                    Console.Write(C[j] + " ");
                    k -= C[j];
                    break;
                }
            }
        }

        return dp[X];
    }

    // Driver code
    static void Main(string[] args)
    {
        int X = 21;

        // Set of possible denominations
        int[] arr = { 2, 3, 4, 5 };

        int N = arr.Length;

        // Function Call
        CountMinCoins(X, arr, N);
    }
}