【LeetCode-322】322.零钱兑换（动态规划解决）

零钱兑换

题目描述

给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。

示例 1:

输入: coins = [1, 2, 5], amount = 11
输出: 3
解释: 11 = 5 + 5 + 1
示例 2:

输入: coins = [2], amount = 3
输出: -1

说明:
你可以认为每种硬币的数量是无限的。

最好理解：动态规划解决

完全背包问题

思路：这道题是完全背包问题的变种，采用动态规划维护一个二维数组dp，dp[i][j]表示从第一个元素到第i个元素累计总金额为j时的最少硬币数量，递推公式为：

dp[i][j] = min(dp[i - 1][j], dp[i][j - coins[i]] + 1);   
         = dp[i - 1][j]

解释为：

情况一：如果不考虑当前元素，前i-1个元素就已经累加了总金额为j，那么对应有硬币数dp[i-1][j]，所以硬币数没有增加，依然为dp[i-1][j]

情况二：如果考虑当前元素，前i个元素累加了总金额为 j-coins[i] ，那么再加上第 i 个硬币的面值 coins[i] ，就刚好是总金额 j ，满足要求，这里为什么是 dp[i][j-coins[i]]，而不是 dp[i-1][j-coins[i]] ，是因为这里的硬币是可以重复选的，类比背包是可以无限拿的，所以要考虑当前第 i 个元素已经选过的情况下，如果再选一个硬币的情况（这就是完全背包的通项公式，如果还不了解自行查阅完全背包通项递推式），由于硬币数加了 coins[i] 本身，所以 +1，于是我们在两个中选取一个较小值。

二维数组的参考代码如下：

class Solution {
public:
    int coinChange(vector& coins, int amount) {
	sort(coins.begin(), coins.end(), greater());
	int res = -1;
	int **dp = new int *[coins.size() + 1];
	int m = coins.size()+1;
	int n = amount + 1;
	for (int i = 0; i < m; i++) {
		dp[i] = new int[n];
	}
	for (int i = 1; i < n; i++) {
		dp[0][i] = amount+1;
	}
	for (int i = 0; i < m; i++) {
		dp[i][0] = 0;
	}
	for (int i = 1; i < m; i++) {
		for (int j = 1; j < n; j++) {
			if ((j - coins[i - 1]) >= 0) {
				dp[i][j] = min(dp[i - 1][j], dp[i][j - coins[i - 1]]+1);
			}
            else{
                dp[i][j]=dp[i-1][j];
            }
		}
	}
	res = dp[m - 1][amount]==(amount+1)?-1:dp[m - 1][amount];
	for (int i = 0; i < m; i++) {
		delete[] dp[i];
	}
	delete[] dp;
	return res;        
    }
};

优化空间复杂度，二维数组降为一维

空间复杂度降为一维，递推公式为：

dp[i] = min(dp[i], dp[i - coins[j]] + 1);

意思是当零钱为 i 元需要的最少硬币数 = 第i元 - 硬币中所有出现的可能的小于i元的硬币的出现次数 + 1。这里的 j 从0循环到 coins.size()-1，这里dp需要初始化为一个很大的数，但是不能是INT_MAX，否则+1操作会发生数值溢出。

/*
使用第一个测试用例
步骤1.f(n)只与f(n-1)、f(n-2)、f(n-5)有关系
步骤2.f(n)=min{ 1+f(n-1), 1+f(n-2), 1+f(n-5) }
*/
class Solution {
    
    public int coinChange(int[] coins, int amount) {
         // 自底向上的动态规划
        if(coins.length == 0) {
            return -1;
        }
        
        //实现步骤1：用数组dp保存f(n)
        
        // dp[n]的值： 表示的凑成总金额为n所需的最少的硬币个数
        int[] dp = new int[amount + 1];
        //给dp数组初始化,每个元素值为amount+1
        Arrays.fill(dp,amount + 1);
        dp[0] = 0;
        
        for(int i = 1; i < dp.length; i++) {
            
            //实现步骤2：选择哪一个硬币，并求出最小值=f(n),在这里f(n)=dp[i]
                
            for(int j = 0; j < coins.length; j++) {             
                if(i - coins[j] < 0) {
                    // 子问题无解，跳过（表示当前选择的硬币值过大）
                    continue;
                }
                dp[i] = Math.min(dp[i - coins[j]] + 1, dp[i]);
            }
        }
        return dp[amount] == amount + 1 ? -1 : dp[amount];
    }
}

推荐的思路学习：
动态规划解题套路框架
完全背包问题解法参考