一篇文章解决所有常见“零钱问题”-Java贪心+DP
1. 无限个数的凑零钱问题
我们经常会遇到这种问题（其实在生活中也很常见）：
-----------
例1：
设有n种不同面值的硬币，现要用这些面值的硬币来找开待凑钱数m，可以使用的各种面值的硬币个数不限。
找出最少需要的硬币个数？
如：有4种硬币，分别是1,2,5,10； 现在需要用最少硬币凑出来目标值：23，怎么做？
------------
很明显，我们一眼就可以看出来，最少4个（2个10,1个2，1个1）. 但是计算机怎么解决呢？
以下介绍了两种方法，分别是常见的贪心和动态规划。
1.1 贪心
贪心的思想就是每次只着眼当前，只看局部最优，那么就是先用面值大的，如果target小于面值大的，再考虑小的。
代码如下：
// 每种硬币个数无限
public static int getMinCoin1(int[] money, int target){
int res = 0;
for (int i=money.length-1; i>=0;i--){
while (target>=money[i]){
target -= money[i];
res += 1;
}
}
return target==0?res:-1;
}值得注意的是：贪心并不适合所有情况！
贪心算法适合的条件：零钱面值的倍数满足大于等于2倍的关系！！！
【有关不满足2倍关系不能使用贪心的例子】
*********
例2：
硬币面值为{1,2,5,7,10}，若要凑出14，贪心算法结果会是3（10+2+2），但其实应该是2（7+7）.
*********
此时就要考虑使用DP了
1.2 动态规划
其实，无限个数情况下的最少零钱问题，就是一个（最小）完全背包问题。（如果不太了解背包问题的话，建议看一下背包九讲，或者我后边可能会专门针对背包问题写一篇文章。）
下边是两种DP方法求解无限零钱问题。
代码：
// DP解法 - 每种硬币个数无限
public static int getMinCoin3(int[] money, int target){
if(target==0)
return 0;
if(money==null || money.length==0)
return -1;
int[] dp = new int[target+1];
Arrays.fill(dp,target+1);
dp[0] = 0;
for (int i = 0; i < target+1; i++) {
for (int j=0;j=money[j];j++) {
dp[i] = Math.min(dp[i],dp[i-money[j]]+1);
}
// System.out.println(Arrays.toString(dp));
}
return dp[target]==target+1?-1:dp[target];
}
// DP解法 - 每种硬币个数无限
// 其实是个(最小)完全背包问题
public static int getMinCoin33(int[] money, int target){
if(target==0)
return 0;
if(money==null || money.length==0)
return -1;
int[] dp = new int[target+1];
Arrays.fill(dp,target+1);
dp[0] = 0;
for (int i = 0; i < money.length; i++) {
for (int j = money[i]; j <= target; j++) {
dp[j] = Math.min(dp[j],dp[j-money[i]]+1);
}
}
// System.out.println(Arrays.toString(dp));
return dp[target]==target+1?-1:dp[target];
} 1.3 小结
（1）可以用贪心的例子
int[] money1 = {1,2,5,10};
（2）不可以用贪心的例子：
int[] money2 = {1,2,5,7,10};
System.out.println(getMinCoin1(money2,14)); // 3：error
System.out.println(getMinCoin3(money2,14)); // 2
System.out.println(getMinCoin33(money2,14)); // 2
如上例子（2），贪心算法的结果是错误的，用DP，则可以求出正确结果。
2. 有限零钱个数的最少零钱问题
-----------
例3：
设有n种不同面值的硬币，现要用这些面值的硬币来找开待凑钱数m，可以使用的各种面值的硬币又有限个（且各不相同）。
找出最少需要的硬币个数？
如：有4种硬币，分别是1,2,5,10； 分别有【3,2,5,1】个，现在需要用最少硬币凑出来目标值：23，怎么做？
------------
此时显然之前的方法不行了，因为硬币10的个数只有1个。此时应为最少6个（4个5, 1个2, 1个1）.
这种问题怎么用代码解决呢？（如下）
2.1 贪心
有限零钱个数的贪心情况和无限个数其实差别不大，主要是需要增加一个条件“判断该类型的零钱是否用完”。
代码：
// 每种硬币个数有限
public static int getMinCoin2(int[] money, int[] counts, int target){
int res = 0;
for (int i=money.length-1; i>=0;i--){
for (int j = 0; j < counts[i] && target>=money[i]; j++) {
target -= money[i];
res += 1;
}
}
return target==0?res:-1;
}
2.2 动态规划
有限零钱个数的凑零钱问题，其实就是一个（最小）多重背包问题。
代码：
// DP解法 - 每种硬币个数有限
// 其实是个(最小)多重背包问题
private static int getMinCoin4(int[] money, int[] counts, int target) {
int n = money.length;
int[] dp = new int[target+1];
Arrays.fill(dp,target+1);
dp[0] = 0;
for (int i = 0; i < n; i++) {
int w = money[i];
for (int j = target; j >= 0; j--) {
for (int k = 1; k<=counts[i] && k*w <= j; k++) { // 个数遍历写在最内层
dp[j] = Math.min(dp[j],dp[j-w*k]+k);
}
}
}
return dp[target];
}
2.3 小结
（1）可以使用贪心算法的例子：
int[] money1 = {1,2,5,10};
int[] counts = {3,4,2,1};
System.out.println(getMinCoin2(money1,counts,27));
System.out.println(getMinCoin4(money1,counts,27));
（2）不可以使用贪心算法的例子
int[] money2 = {1,2,5,7,10};
int[] counts2 = {1,1,3,2,2};
System.out.println(getMinCoin2(money2,counts2,14)); // -1，error
System.out.println(getMinCoin4(money2,counts2,14)); // 2
3. 总结
看到这里，应该不难发现，这两种（有限/无限个数）零钱问题，竟然都可以用背包问题解决！神奇的背包，确实有必要学习一下。
本文介绍的并不太详细，重点在于对比“贪心算法”和“动态规划”，如有不恰当之处，还望见谅。
------
以上均是个人的一些理解，如有错误还望批评指正。