Dynamic Programming | Set 7 (Coin Change)

Given a value N, if we want to make change for N cents, and we have infinite supply of each of S = { S1, S2, .. , Sm} valued coins, how many ways can we make the change? The order of coins doesn’t matter.

For example, for N = 4 and S = {1,2,3}, there are four solutions: {1,1,1,1},{1,1,2},{2,2},{1,3}. So output should be 4. For N = 10 and S = {2, 5, 3, 6}, there are five solutions: {2,2,2,2,2}, {2,2,3,3}, {2,2,6}, {2,3,5} and {5,5}. So the output should be 5.

1) Optimal Substructure
To count total number solutions, we can divide all set solutions in two sets.
1) Solutions that do not contain mth coin (or Sm).
2) Solutions that contain at least one Sm.
Let count(S[], m, n) be the function to count the number of solutions, then it can be written as sum of count(S[], m-1, n) and count(S[], m, n-Sm).

Therefore, the problem has optimal substructure property as the problem can be solved using solutions to subproblems.

2) Overlapping Subproblems
Following is a simple recursive implementation of the Coin Change problem. The implementation simply follows the recursive structure mentioned above.

#include<stdio.h>

// Returns the count of ways we can sum  S[0...m-1] coins to get sum n
int count( int S[], int m, int n )
{
    // If n is 0 then there is 1 solution (do not include any coin)
    if (n == 0)
        return 1;
    
    // If n is less than 0 then no solution exists
    if (n < 0)
        return 0;

    // If there are no coins and n is greater than 0, then no solution exist
    if (m <=0 && n >= 1)
        return 0;

    // count is sum of solutions (i) including S[m-1] (ii) excluding S[m-1]
    return count( S, m - 1, n ) + count( S, m, n-S[m-1] );
}

// Driver program to test above function
int main()
{
    int i, j;
    int arr[] = {1, 2, 3};
    int m = sizeof(arr)/sizeof(arr[0]);
    printf("%d ", count(arr, m, 4));
    getchar();
    return 0;
}

It should be noted that the above function computes the same subproblems again and again. See the following recursion tree for S = {1, 2, 3} and n = 5.
The function C({1}, 3) is called two times. If we draw the complete tree, then we can see that there are many subproblems being called more than once.

C() --> count()
                              C({1,2,3}, 5)                     
                           /                \
                         /                   \              
             C({1,2,3}, 2)                 C({1,2}, 5)
            /     \                        /         \
           /        \                     /           \
C({1,2,3}, -1)  C({1,2}, 2)        C({1,2}, 3)    C({1}, 5)
               /     \            /    \            /     \
             /        \          /      \          /       \
    C({1,2},0)  C({1},2)   C({1,2},1) C({1},3)    C({1}, 4)  C({}, 5)
                   / \      / \       / \        /     \    
                  /   \    /   \     /   \      /       \ 
                .      .  .     .   .     .   C({1}, 3) C({}, 4)
                                               /  \
                                              /    \  
                                             .      .

Since same suproblems are called again, this problem has Overlapping Subprolems property. So the Coin Change problem has both properties (see this and this) of a dynamic programming problem. Like other typical Dynamic Programming(DP) problems, recomputations of same subproblems can be avoided by constructing a temporary array table[][] in bottom up manner.

Dynamic Programming Solution

#include<stdio.h>

int count( int S[], int m, int n )
{
    int i, j, x, y;

    // We need n+1 rows as the table is consturcted in bottom up manner using 
    // the base case 0 value case (n = 0)
    int table[n+1][m];
   
    // Fill the enteries for 0 value case (n = 0)
    for (i=0; i<m; i++)
        table[0][i] = 1;

    // Fill rest of the table enteries in bottom up manner  
    for (i = 1; i < n+1; i++)
    {
        for (j = 0; j < m; j++)
        {
            // Count of solutions including S[j]
            x = (i-S[j] >= 0)? table[i - S[j]][j]: 0;

            // Count of solutions excluding S[j]
            y = (j >= 1)? table[i][j-1]: 0;

            // total count
            table[i][j] = x + y;
        }
    }
    return table[n][m-1];
}

// Driver program to test above function
int main()
{
    int arr[] = {1, 2, 3};
    int m = sizeof(arr)/sizeof(arr[0]);
    int n = 4;
    printf(" %d ", count(arr, m, n));
    return 0;
}

Time Complexity: O(mn)

Following is a simplified version of method 2. The auxiliary space required here is O(n) only.

int count( int S[], int m, int n )
{
    // table[i] will be storing the number of solutions for
    // value i. We need n+1 rows as the table is consturcted
    // in bottom up manner using the base case (n = 0)
    int table[n+1];

    // Initialize all table values as 0
    memset(table, 0, sizeof(table));

    // Base case (If given value is 0)
    table[0] = 1;

    // Pick all coins one by one and update the table[] values
    // after the index greater than or equal to the value of the
    // picked coin
    for(int i=0; i<m; i++)
        for(int j=S[i]; j<=n; j++)
            table[j] += table[j-S[i]];

    return table[n];
}

Thanks to Rohan Laishram for suggesting this space optimized version.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

References:
http://www.algorithmist.com/index.php/Coin_Change





  • rockon

    @geeksforgeeks:disqus
    That was very helpful. I have one question though.
    How would I find the number of ways to make the change when order of coin matters ?

  • Ashish

    Hello,
    Anyone plz tell the method how we can print all solutions possible for coin change……..

  • Wellwisher

    C# implementation of Vending machine problem through a DP approach.

    http://onestopinterviewprep.blogspot.com/2014/03/vending-machine-problem-dynamic.html

  • Guest

    For the input n=4 ,m=3 and s={1,2,3} I get table something like
    1 1 1
    1 1 1
    1 2 2
    1 2 3
    1 3 4

    Can somebody explain the meaning of table?

    How to interpret the statement

    // Count of solutions including S[j]
    x = (i-S[j] >= 0)? table[i – S[j]][j]: 0; as Count of solutions including S[j] ?

    // Count of solutions excluding S[j]
    y = (j >= 1)? table[i][j-1]: 0; as Count of solutions excluding S[j] ?

  • Paparao Veeragandham

    Rohan Laishram implemetation does not – Idea is good
    Full code here:
    #include
    #include
    #include
    int minCoins( int a[], int N, int S )
    {
    /* N: Length of the array */
    int i , j, sum[S + 1 ];

    memset(sum, 0 , sizeof(sum));
    sum[0] = 1;
    // for(i = 0 ; i< N; i++)
    // sum[a[i] ] =1;

    for ( i = 0 ; i < N ; i++)
    {
    for ( j = a[i] ; j <= S ; j++)
    {
    if ( j == a[i])
    sum[a[i]] = 1;
    else if( sum[j – a[i]])
    {

    sum[j] = sum[j – a[i]] + 1;
    }
    }
    }
    for( i = 0 ; i <= S; i++)
    printf("%d ", sum[i]);
    printf("Endn");
    if ( sum[S] == 0 ) return -1;

    return sum[S];

    }
    int main()
    {
    int a[5] = { 1,3,5};
    printf("%d", minCoins(a,3,12) );
    return 0;
    }

  • Paparao Veeragandham

    Rohan Lai

  • naresh

    typo: “The function C({1,3}, 1) is called two times”. It should be “The function C({1},3) is called two times”.

    • GeeksforGeeks

      Thanks for pointing this out. We have updated the post.

  • nikelback

    what’s the explanation of the optimized version?

  • neelabhsingh

    @geeksforgeeks In 2) Overlapping Subproblems last line
    return count( S, m – 1, n ) + count( S, m, n-S[m-1] );
    // count is sum of solutions (i) including S[m-1] (ii) excluding S[m-1], please correct the comment according to the function. like

    count is sum of solutions (i) excluding S[m-1], (ii) including S[m-1]

  • Parantap Sharma

    while i may be incorrect… i feel that your first dynamic programming code is wrong… try it in case: 3 coins 1,3,5 are available one each and you want to get a sum of 2 out of those… your code is saying that there is one way to do so… while the correct answer is that no such way exists…

    • Parantap Sharma

      and the correct code according to me is:

      if(j!=0) x=(i-S[j]>=0)?table[i-S[j]][j-1]:0;

      else x=(i-S[j]==0)?1:0;

      instead of that one line:

      x = (i-S[j] >= 0)? table[i – S[j]][j]: 0;

      please someone clarify my doubt soon

  • praveen selvaraj

    how do we approach this problem when we can use each coin only once?

  • Vivek VV

    Can anyone please elaborate how we are splitting the problem in two halves.
    How count(S,m,n) = count(S,m-1,n) + count(S,m,n-S[m])
    Thanks in advance

    • Prashanth

      count(S,m-1,n) = excluding the mth coin in the solution and
      count(S,m,n-S[m]) = including the mth coin in the solution

  • ctrl513

    package com.nbethi.top20.dp;

    public class MinCoinNR {

    public static void main(String args[]) {

    int[] a = { 2, 3, 5, 6 };

    // int[] a = { 1, 3, 4 };

    int s = 119;

    int res;

    long start, end;

    start = System.currentTimeMillis();

    res = minCoinNR(a, s);

    end = System.currentTimeMillis();

    System.out.println(" result : " + res);

    System.out.println(" time : " + (end - start));

    System.out.println("DONE");

    }

    public static int minCoinNR(int[] a, int s) {

    int[] MEM = new int[s + 1];

    int t;

    for (int i = 0; i < MEM.length; i++) {

    MEM[i] = Integer.MAX_VALUE - 1;

    }

    for (int i = 1; i <= s; i++) {

    for (int j = 0; j 0)

    MEM[i] = Math.min(MEM[i], MEM[i - a[j]] + 1);

    if (t < 0)

    MEM[i] = Math.min(MEM[i], Integer.MAX_VALUE);

    }

    }

    return MEM[s];

    }

    }

    • ctrl513

      this is to print the minimal no of coins required to get the sum S

      • Khajjal

        Thanks
        very good code.
        could u please explain , why are u initializing the MEM[i] with Integer.MAX_VALUE – 1

  • Kuldeep Kumar

    As simple Solution as recursive one with memoization

    #include
    #include
    #define n 3
    #define s 50
    using namespace std;
    int arr[]={1,2,3},dp[n+1][s+1];
    int exchange(int i,int num){
    if(dp[i][num]!=0)
    return dp[i][num];
    if(num==0)
    return 1;
    if(num<0)
    return 0;
    if (i = 1)
    return 0;
    else
    {
    dp[i][num]=exchange(i,num-arr[i-1])+exchange(i-1,num);
    return dp[i][num];
    }
    }
    int main(){
    memset(dp,0,sizeof(dp));
    cout<<exchange(n,s)<<"n";
    return 0;
    }

  • Vinodhini

    How would we modify the logic to print all the combinations?
    I know we could go for recursion. But how could i use the DP table constructed and print them?

  • aayushkumar

    suppose we have m coins to achieve n sum nd duplications are allowed why this gives wrongs ans??

    for(i=1;i<=n;i++)
    {
    for(j=0;j<m;j++)
    {
    arr[i]=arr[i]+arr[i-coin[j]];
    }
    }

  • http://programearly.com ProgramEarly

    Heard this can solved using stacks/linkedlist with no recursion? Know how to do it?

    Thanks

  • coderAce

    Would really like to thank and encourage GeeksforGeeks for this amazing work they are doing. It’s really a great collection of resources you are developing and I am finding it extremely helpful to ramp up on algorithms once again as I was out of practice for more than a year or so. Please keep up the good work. A lot of people are getting benefited by your efforts :)

  • makeit

    really nice

     
    /* Paste your code here (You may delete these lines if not writing code) */
     
  • atul

    here is the space optimized code for DP approach :-

     
    part[0]=1;
    for(i=0;i<n;i++)
    {
       for(j=arr[i];j<=sum;j++)
       {
            part[j]=part[j] + part[j-arr[i]]
       }
    }
    return part[sum];
    
     
    • atul

      ignore….it has been already added…

  • atul
     
    /* Paste your code here (You may delete these lines if not writing code) */
     
  • lohith
     
    import java.util.ArrayList;
    import java.util.HashMap;
    
    public class Coins {
    
    	/**
    	 * @param args
    	 */
    	
    	
    	
    	
    	public static void main(String[] args) {
    		int N = 4;
    		int[] S = { 1, 2, 3 };
    
    		HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
    		for(int i=0;i<S.length;i++){
    			map.put(S[i], 0);
    		}
    		ArrayList<HashMap<Integer, Integer>> values = calcualte(N, S,map);
    
    		for (HashMap<Integer, Integer> temp : values)
    			System.out.println(temp);
    
    	}
    
    	private static ArrayList<HashMap<Integer, Integer>> list = new ArrayList<HashMap<Integer, Integer>>();
    
    	private static ArrayList<HashMap<Integer, Integer>> calcualte(int n,
    			int[] s, HashMap<Integer, Integer> map) {
    
    		if (n == 0) {
    			list.add(map);
    			return list;
    		}
    
    		for (int i = 0; i < s.length; i++) {
    			if (n - s[i] >= 0) {
    				
    			     HashMap<Integer, Integer> temp = (HashMap<Integer, Integer>)map.clone();
    				 temp.put( s[i], temp.get(s[i])+1);
    				 calcualte(n- s[i], s,temp);
    				
    			}
    
    		}
    
    		return list;
    	}
    
    }
    
    
    
    
    
    
     
  • bidisha

    can you explain the logic…

  • https://sites.google.com/site/kahanirobotic/home reza

    hi.
    help me in state that
    if Coins Can not repeat whats doing???????????????

  • ab

    I have a variant of this problem. In some country suppose some of the coins are more popular than other coins, so we need to produce a set which will try to maximize the number of the popular coin. This effort will be aligned with some optimized relation, like maximum x% of increase in the number of coins than the most optimized soln.
    When i tried, it seemed difficult to align the dynamic approach with some given relation, any idea if i try to avoid the recursive approach??

  • AjithPrasanth

    Simple recursive approach, no extra space.

     
    import java.util.Arrays;
    
    public class CoinChange {
    	private static int opCount = 0;
    	private static int sum = 10;
    	private static int[] coins = { 2, 5, 3, 6 };
    
    	public static void main(String[] args) {
    		Arrays.sort(coins);
    		coinCount(0, 0);
    		System.out.println(opCount);
    	}
    
    	private static int coinCount(int currValue, int lastEltIndex) {
    		if (currValue == sum) {
    			opCount++;
    			// Indicating to not process any further coins
    			return -1;
    		}
    
    		for (int i = lastEltIndex; i < coins.length; i++) {
    			// Adding the coin would exceed the sum
    			if ((coins[i] + currValue) > sum )
    				break;
    
    			int n = coinCount(currValue + coins[i], i);
    
    			// Sum is already reached
    			if (n == -1)
    				break;
    		}
    
    		return 0;
    	}
    }
    
     
  • kartikaditya

    import java.util.Arrays;

    public class CoinChange {
    public static int getPossibleAccounting(int sum, int vals[]) {
    if (sum < 0) {
    return -1;
    }
    if (vals == null || vals.length == 0) {
    return -1;
    }
    Arrays.sort(vals);
    for (int i = 1; i < vals.length; ++i) {
    if (vals[i – 1] == vals[i]) {
    return -1;
    }
    }

    int dp[] = new int[sum + 1];
    dp[0] = 1;
    for (int i = 0; i < vals.length; ++i) {
    for (int j = vals[i]; j <= sum; ++j) {
    dp[j] += dp[j – vals[i]];
    }
    }
    return dp[sum];
    }

    public static void main(String[] args) {
    System.out.println(getPossibleAccounting(4, new int[]{2, 3, 1}));
    System.out.println(getPossibleAccounting(10, new int[]{2, 3, 5, 6}));
    }
    }

    • bidisha

      can you explain the logic…

       
      /* Paste your code here (You may delete these lines if not writing code) */
       
  • http://rohanlaishram.com Rohan Laishram

    A simplified version with reduced space complexity O(n)

     
    int count( int S[], int m, int n )
    {
        int table[n+1];
        memset(table,0,sizeof(table));
        table[0]=1;
        for(int i=0;i<m;i++)
             for(int j=S[i];j<=n;j++)table[j]+=table[j-S[i]];
        return table[n];
    }
     
    • kartik

      @Rohan Laishram: Thanks for suggesting a space optimized version of method 2. We will analyze it and add if it works fine, then will add it to the original post.

    • makeit

      really nice

    • ctrl513

      this does not work table[j-S[i]] might go into negative numbers

      • Zhongen

        No, since j >= S[i]

  • camster

    Hi , Here is the proposed combinatorial algebra solution. Thank you.Camster

     
    5x + 10y + 25z = 100
    
    
    floor(100/10) + 5 = 15
    floor(75/10) + 5  = 12
    floor(50/10) + 5  = 10
    floor(25/10) + 5  =  7
    floor(0/10) + 5   =  5
    
    15 + 12 + 10 + 7 + 5 = 49 ways
    
    /* Paste your code here (You may delete these lines if not writing code) */
     
    • kartik

      @camster: Could you please explain more about this approach. Some pseudo code or code in C/C++ would be helpful.

  • aayush kumar

    what will ans when there is finite supply of coins???

    • geek4u

      A recursive implementation of finite supply variation. One additional parameter C[] is used for given supply of coins.

       
      #include<stdio.h>
      
      // Returns the count of ways we can sum  S[0...m-1] coins to get sum n
      int count( int S[], int C[], int m, int n )
      {
          int x = 0;
      
          // If n is 0 then there is 1 solution (do not include any coin)
          if (n == 0)
              return 1;
      
          // If n is less than 0 then no solution exists
          if (n < 0)
              return 0;
      
          // If there are no coins and n is greater than 0, then no solution exist
          if (m <=0 && n >= 1)
              return 0;
      
          if (C[m-1] > 0)
          {
              C[m-1]--;
              x = count( S, C, m, n-S[m-1] );
              C[m-1]++;
          }
      
          // count is sum of solutions (i) including S[m-1] (ii) excluding S[m-1]
          return count( S, C, m - 1, n ) + x;
      }
      
      // Driver program to test above function
      int main()
      {
          int i, j;
          int S[] = {1, 2, 3};
          int C[] = {3, 2, 1};
      
          // Only two solution {1,1,1,2,3} and {1,2,2,3}
          int m = sizeof(S)/sizeof(S[0]);
          int n = 8;
          printf("%d ", count(S, C, m, n));
          getchar();
          return 0;
      }