DP7 两道换硬币的问题 Coin Change @geeksforgeeks

1 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.

两种思路：

1）http://www.cs.ucf.edu/~dmarino/ucf/cop3530/lectures/COP3530DynProg02.doc

特别注意到换完的硬币是没有顺序的，所以要impose order

2）http://www.geeksforgeeks.org/dynamic-programming-set-7-coin-change/

http://www.cnblogs.com/python27/p/3303721.html

http://www.mathblog.dk/project-euler-31-combinations-english-currency-denominations/

考虑是否取最后一个硬币，转换为背包问题

package DP;

import java.util.Arrays;

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

*/
public class CoinChange1 {

public static int MEM[] = new int[10001];   // Can support up to 10000 peso value

public static void main(String[] args) {

int coins[] = {1, 2, 3};  // Available coin denominations
Arrays.sort(coins);
int coinKinds = coins.length;
int sum = 4;
System.out.println(countRec_1st(coins, coinKinds, sum, coins[coins.length-1]));
System.out.println(countRec_2nd(coins, coinKinds, sum));
System.out.println(countDP_1st(coins, coinKinds, sum));
System.out.println(countDP2D_2nd(coins, coinKinds, sum));
System.out.println(countDP1D_2nd(coins, coinKinds, sum));
}

//====================================第一种思路
/*
max 用来保持order，否则就会有重复，如(1,2),(2,1)
*/
public static int countRec_1st(int coins[], int coinKinds, int sum, int max){
if(sum < 0){
return 0;
}
if(sum == 0){
return 1;
}

int ways = 0;
for(int i=0; i<coinKinds; i++){
if(max >= coins[i]){
ways += countRec_1st(coins, coinKinds, sum-coins[i], coins[i]);
}
}
return ways;
}

// http://www.cnblogs.com/python27/p/3303721.html // dp[i][j] = sum(dp[i-1][j-k*coins[i-1]]) for k = 1,2,..., j/coins[i-1]
// dp[0][j] = 1 for j = 0, 1, 2, ..., sum
public static int countDP_1st(int[] coins, int coinKinds, int sum){
int[][] dp = new int[coinKinds+1][sum+1];

for(int i=0; i<=coinKinds; i++){
for(int j=0; j<=sum; j++){
dp[i][j] = 0;
}
}
for(int i=0; i<=coinKinds; i++){
dp[i][0] = 1;
}

for(int i=1; i<=coinKinds; i++){	// 币的面值
for(int j=1; j<=sum; j++){		// 要凑成的数量
dp[i][j] = 0;
for(int k=0; k<=j/coins[i-1]; k++){
dp[i][j] += dp[i-1][j-k*coins[i-1]];
}
}
}

return dp[coinKinds][sum];
}

//====================================第二种思路

// Return the count of ways we can sum coins[0...m-1] coins to get sum
public static int countRec_2nd(int coins[], int coinKinds, int sum){
if(sum == 0){	// If n is less than 0 then no solution exists
return 1;
}
if(sum < 0){	// If n is less than 0 then no solution exists
return 0;
}
if(coinKinds<=0 && sum>=1){	// If there are no coins and n is greater than 0, then no solution exist
return 0;
}
// count is sum of solutions (i) including coins[m-1] (ii) excluding coins[m-1]
// 两种情况：
// 1. 不使用最后一个硬币，因此实际上就是用少了最后一个硬币的coins来凑sum
// 2.使用最后一个硬币，因此sum的总数减少，因为每个硬币都有无数个，所以m不变
return countRec_2nd(coins, coinKinds-1, sum) + countRec_2nd(coins, coinKinds, sum-coins[coinKinds-1]);
}

public static int countDP2D_2nd(int[] coins, int coinKinds, int sum){
// We need n+1 rows as the table is constructed in bottom up manner using
// the base case 0 value case (n = 0)
int[][] dp = new int[sum+1][coinKinds];

// Fill the entries for 0 value case (sum = 0)
for(int i=0; i<coinKinds; i++){
dp[0][i] = 1;
}

// Fill rest of the table entries in bottom up manner
for(int i=1; i<=sum; i++){		// sum
for(int j=0; j<coinKinds; j++){		// coins m
// Count of solutions including S[j]
int x = (i-coins[j]>=0) ? dp[i-coins[j]][j] : 0;	// 要满足i-coins[j]>=0
// Count of solutions excluding S[j]
int y = (j>=1) ? dp[i][j-1] : 0;	// 要满足j-1>=0
dp[i][j] = x + y;
}
}
return dp[sum][coinKinds-1];
}

public static int countDP1D_2nd(int[] coins, int coinKinds, int sum){

// dp[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)
int[] dp = new int[sum+1];

dp[0] = 1;	// Base case (If given value is 0)
// 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<coinKinds; i++){			// coins m
for(int j=coins[i]; j<=sum; j++){	// sum
dp[j] += dp[j-coins[i]];
}
}
return dp[sum];
}

}

2 What is the smallest number of coins to change? 如果换，最少会有多少枚硬币？

http://www.columbia.edu/~cs2035/courses/csor4231.F11/dynamic.pdf

C[p] = min{C[p-di]+1} 

package DP;

import java.util.Arrays;

/**
A country has coins with denominations
1 = d1 < d2 < · · · < dk.

You want to make change for n cents, using the smallest number

*/
public class CoinChange2 {

public static int MEM[] = new int[10001];   // Can support up to 10000 peso value
public static int coins[] = {1, 2, 3};  // Available coin denominations

public static void main(String[] args) {
int n = 4;
System.out.println(minCoins(n));
System.out.println(minCoins_DP(n));
}

// 记忆化搜索，top-down 递归
public static int minCoins(int n) {
if(n < 0)
return Integer.MAX_VALUE -1;
else if(n == 0)
return 0;
else if(MEM
!= 0)    // If solved previously already
return MEM
;
else {
// Look for the minimal among the different denominations
MEM
= 1+minCoins(n-coins[0]);
for(int i = 1; i < coins.length; i++)
MEM
= Math.min(MEM
, 1+minCoins(n-coins[i]));
return MEM
;
}
}

// bottom-up DP
public static int minCoins_DP(int n){
int[] minCoins = new int[n+1];
Arrays.fill(minCoins, Integer.MAX_VALUE);

// 第一个硬币
minCoins[0] = 0;

// 算出n前的每一个可换硬币的数量
for(int i=1; i<=n; i++){
// 根据递推公式，看看硬币可拆分的可能性
for(int j=0; j<coins.length; j++){
if(coins[j] <= i){
minCoins[i] = Math.min(minCoins[i], 1+minCoins[i-coins[j]]);
}
}
}

return minCoins
;
}

}