钱币组合问题（动态规划）

钱币组合问题：（每种硬币不限次数）

假设我们有8种不同面值的硬币｛1，2，5，10，20，50，100，200｝，用这些硬币组合够成一个给定的数值n。例如n=200，那么一种可能的组合方式为200 = 3 * 1 + 1＊2 + 1＊5 + 2＊20 + 1 * 50 + 1 * 100. 问总过有多少种可能的组合方式？

解题思路：

给定一个数值sum，假设我们有m种不同类型的硬币{V1, V2, ..., Vm}，如果要组合成sum，那么我们有

sum = x1 * V1 + x2 * V2 + ... + xm * Vm

求所有可能的组合数，就是求满足前面等值的系数{x1, x2, ..., xm}的所有可能个数。

[思路1] 当然我们可以采用暴力枚举，各个系数可能的取值无非是x1 = {0, 1, ..., sum / V1}, x2 = {0, 1, ..., sum/ V2}等等。这对于硬币种类数较小的题目还是可以应付的，比如华为和创新工厂的题目，但是复杂度也很高O（sum/V1 * sum/V2 * sum/V3 * ...）

[思路2] 从上面的分析中我们也可以这么考虑，我们希望用m种硬币构成sum，根据最后一个硬币Vm的系数的取值为无非有这么几种情况，xm分别取｛0, 1, 2, ..., sum/Vm｝，换句话说，上面分析中的等式和下面的几个等式的联合是等价的。

sum = x1 * V1 + x2 * V2 + ... + 0 * Vm

sum = x1 * V1 + x2 * V2 + ... + 1 * Vm

sum = x1 * V1 + x2 * V2 + ... + 2 * Vm

...

sum = x1 * V1 + x2 * V2 + ... + K * Vm  

其中K是该xm能取的最大数值K = sum / Vm。可是这又有什么用呢？不要急，我们先进行如下变量的定义：

dp[i][sum] = 用前i种硬币构成sum 的所有组合数。

那么题目的问题实际上就是求dp[m][sum]，即用前m种硬币（所有硬币）构成sum的所有组合数。在上面的联合等式中：当xn=0时，有多少种组合呢？ 实际上就是前i-1种硬币组合sum，有dp[i-1][sum]种！ xn = 1 时呢，有多少种组合？ 实际上是用前i-1种硬币组合成(sum - Vm)的组合数，有dp[i-1][sum -Vm]种; xn =2呢， dp[i-1][sum - 2 * Vm]种，等等。所有的这些情况加起来就是我们的dp[i][sum]。所以：

dp[i][sum] = dp[i-1][sum - 0*Vm] + dp[i-1][sum - 1*Vm]

+ dp[i-1][sum - 2*Vm] + ... + dp[i-1][sum - K*Vm]; 其中K = sum / Vm

换一种更抽象的数学描述就是：

递归公式

通过此公式，我们可以看到问题被一步步缩小，那么初始情况是什么呢？如果sum=0，那么无论有前多少种来组合0，只有一种可能，就是各个系数都等于0；

dp[i][0] = 1   // i = 0, 1, 2, ... , m

如果我们用二位数组表示dp[i][sum], 我们发现第i行的值全部依赖与i-1行的值，所以我们可以逐行求解该数组。如果前0种硬币要组成sum，我们规定为dp[0][sum] = 0. 

思路一：暴力穷举

每种硬币最多为N/coins，当n较小时，可以穷举出,注意本程序需要n>200,否则需要更改if判断的位置。（时间超时）

   

public static int cb = 0;
        public static void brute(int[] coins,int n){
            //有多少种币就有多少个for,此题共有7种
            for(int i =0;i<=n/coins[0];i++){
                for(int j =0;j<=n/coins[1];j++){
                    for(int k =0;k<=n/coins[2];k++){
                        for(int l =0;l<=n/coins[3];l++){
                            for(int m =0;m<=n/coins[4];m++){
                                for(int o =0;o<=n/coins[5];o++){
                                    for(int p =0;p<=n/coins[6];p++){
                                        if((coins[0]*i+coins[1]*j+coins[2]*k+coins[3]*l+coins[4]*m+coins[5]*o+coins[6]*p)==n){
                                            cb++;
                                            //System.out.println("1 2 5 10 20 50 100 各使用"+i+j+k+l+m+o+p+"种");
                                        };
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

思路二：分支限界，深度遍历

去掉大于N的情况，注意每种硬币允许使用多次，且122与212、221属于同一种情况，所以限定每次使用的币种（coins[i]）应大于等于上次使用的币种（coins[coinlocation]） （时间超时）

   

        static int cc = 0;    //统计总共的数目
        static int[] sum = {0,0,0,0,0,0,0};//用于打印使用状况
        /**
         * @param coins 钱币列表
         * @param n 总金额
         * @param count 当前金额
         * @param coinlocation 当前使用币种的下标
         */
        public static void dfs(int[] coins,int n,int count,int coinlocation){
            if(count==n){
                cc++;
                for(int i =0;i<sum.length;i++){
                    System.out.print("使用 "+coins[i]+"元："+sum[i]+"个,");
                }
                System.out.println();
            }else if(count > n){
                return;
            }else {
                //遍历每一种硬币,允许1 2 2，不允许2，1,2
                for(int i=coinlocation;i<coins.length;i++){
                    sum[i]++;
                    dfs(coins,n,count+coins[i],i);
                    sum[i]--;
                }
            }
        }

思路三：动态规划

设d[i][sum]为使用第i中钱币时达到总金额sum的方案数目所以对于钱币i（coins[i]）,可以不使用i、使用一个i、使用两个i......使用sum/coins[i]个i，即个，其中用d[i][0] = 1(只有一种方案，即什么币种也不用)d[0][i] =0(不用任何币种组成任意钱数，没有这种操作)。

   

      public static void dynamic_prommgram(int[] coins,int n){
            int[][] d = new int[coins.length+1][n+1];//length+1表示不适用任何币种、只使用1、只使用1 2 只使用1 2 3......等等，共length+1种情况，且n+1表示总计0、1.....至n元共n+1种情况
            for(int i = 0;i<=coins.length;i++) d[i][0] = 1;
            for(int i = 1 ;i<=coins.length;i++){//因为d[0][i]是0，所以i从1开始
                for(int sum = 1;sum<=n;sum++){//由于d[i][0]==1，所以j从1开始
                    for(int k=0;k<=sum/coins[i-1];k++){//例如，使用面值为1时，对应的coins[]下标是i-1，逻辑上河实际上不是一致的
                        d[i][sum] +=d[i-1][sum-k*coins[i-1]];
                    }                
                }
            }
            System.out.println(d[coins.length][n]);
        }

当然，程序可以简化为一维数组，二维数组的方式易于理解，但一维数组的方式更为简洁，因为d[i][sum]=ξ’d[i-1][X’]=ξ’ξ’d[i-2][X’’]=...即d[i-1]就是累加求和的中间量，所以可以直接使用一维数组表示：

   

        public static void main(String[] args){
            long[] d= new long[201];
            d[0]=1;
            int[] v={1,2,5,10,20,50,100
            };
            for(int i=0;i<7;i++){
                for(int j=v[i];j<201;j++){
                    d[j]+=d[j-v[i]];       //相当于                         
                }
            }     
            System.out.println(200+"的组合方式有"+d[200]+"种");
    }