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[n] != 0)    // If solved previously already
            return MEM[n];
        else {
            // Look for the minimal among the different denominations
            MEM[n] = 1+minCoins(n-coins[0]);
            for(int i = 1; i < coins.length; i++)
                MEM[n] = Math.min(MEM[n], 1+minCoins(n-coins[i]));
            return MEM[n];
        }
    }

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