# 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

## C

```#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;
}
```

## Java

```/* Dynamic Programming Java implementation of Coin
Change problem */
import java.util.Arrays;

class CoinChange
{
static long countWays(int S[], int m, int n)
{
//Time complexity of this function: O(mn)
//Space Complexity of this function: O(n)

// table[i] will be storing the number of solutions
// for value i. We need n+1 rows as the table is
// constructed in bottom up manner using the base
// case (n = 0)
long[] table = new long[n+1];

// Initialize all table values as 0
Arrays.fill(table, 0);   //O(n)

// 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];
}

// Driver Function to test above function
public static void main(String args[])
{
int arr[] = {1, 2, 3};
int m = arr.length;
int n = 4;
System.out.println(countWays(arr, m, n));
}
}
// This code is contributed by Pankaj Kumar
```

## Python

```# Dynamic Programming Python implementation of Coin Change problem
def count(S, m, n):
# We need n+1 rows as the table is consturcted in bottom up
# manner using the base case 0 value case (n = 0)
table = [[0 for x in range(m)] for x in range(n+1)]

# Fill the enteries for 0 value case (n = 0)
for i in range(m):
table[0][i] = 1

# Fill rest of the table enteries in bottom up manner
for i in range(1, n+1):
for j in range(m):
# Count of solutions including S[j]
x = table[i - S[j]][j] if i-S[j] >= 0 else 0

# Count of solutions excluding S[j]
y = table[i][j-1] if j >= 1 else 0

# total count
table[i][j] = x + y

return table[n][m-1]

# Driver program to test above function
arr = [1, 2, 3]
m = len(arr)
n = 4
print(count(arr, m, n))

# This code is contributed by Bhavya Jain
```

Output:
`4`

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.

# Company Wise Coding Practice    Topic Wise Coding Practice

• Suvodip Bhattacharya

#include
#include
#include
using namespace std;

int change(int N,int s[],int start,int sizen,int current)
{

if( N == 0 /*&& start < sizen*/) return 1;
if( N < 0 ) return 0;

else
{
int f=0;
for(int i=start ; i<sizen ; i++)
{
if( current <= i )
f+=change( N-s[i],s,0,sizen,i);
}

return f;
}

}

int main()
{
int s[]={2, 5, 3, 6};
int size=sizeof(s)/sizeof(s[0]);

int N=10;

cout<<change(N,s,0,size,INT_MIN)<<endl;
}

• Guest

@geeksforgeeks:disqus In my opinion the code given by Roshan wont work for every input.
for(int i=0 ; i<m ; i++) {
for(int j=S[i] ; j<=n ; j++)
in the second loop we are incrementing j but what if the coins are not in increasing order (or they are increasing but not in a constant periodic fashion, the above code fails to handle this problem. correct me if i am wrong.

• Guest

@geeksforgeeks:disqus In my opinion the code given by Roshan wont work for every input.
for(int i=0; i<m; i++)
for(int j=S[i]; j<=n; j++)
table[j] += table[j-S[i]];
in the second loop we are incrementing j but what is the coins are not in increasing order (or they are increasing but not in a constant fashion, the above code fails to handle this problem.
Correct me if I am wrong.

• Rahul

sorry it will work just got into the condition part where j<=n

• Rahul

what happens if the array contain an element which is greater than the sum n . i think last algo wont work for that .

• Rachit Pant

Can someone explain the logic of the original solution in this post . How are we splitting the problem.

• Vivek

solution space complexity of O(n)
is given below. pls go through the solution

• Vivek

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

int table[n+1][2];

table[0][0]=table[0][1]=1;

// Fill rest of the table enteries in bottom up manner

int prev=0;
int current=1;
for (j = 0; j < m; j++)
{
for (i = 1; i = 0)? table[i – S[j]][current]: 0;

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

// total count
table[i][current] = x + y;

}
prev=current;
current=(current+1)%2;
}
return table[n][prev];
}

• IDC

Rohan Laishram’s solution is completely wrong. It works only for cases where non of the coins are of the same base – i.e., if S = {1,5,25}. But if all the coins are multiples of each other – let’s say S = {1,2,4} – it will counts repeats of the same denomination.

For instance, let’s use S = {1,2,4} and target V = 8. The return function F(8) = F(7) + F(6) + F(4), according to the algorithm. However, that means it counts F(4) three times, since F(7) and F(6) also include F(4) in their sum. Therefore, the algorithm is invalid.

• IDC

S = {1,5,25} should be something like S={1,10,25}

• samtron92

Since order does not matter, we will impose that our solutions (sets)
are all sorted in non-decreasing order (Thus, we are looking at
sorted-set solutions: collections). For a particular N and (now with the restriction that , our solutions can be constructed in non-decreasing order), the set of solutions for this problem, C(N,m), can be partitioned into two sets:

• 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;

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

please someone clarify my doubt soon

• Mukesh M

All coins 1,3,… are available countless for given solution not like assumption(only one each) you made.

• 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])

• 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]];
}
}

• 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

• 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) {
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…

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

if (n == -1)
break;
}

return 0;
}
}

``` ```

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) */
``` ```
• 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

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

``` ```