LeeCode 322-零钱兑换（经典 动态规划）

322.零钱兑换（经典 动态规划）

前言

博主是前大厂程序猿，不定期分享前端知识与算法。

• 公众号：FE Corner
• wx小程序：FE Corner

欢迎关注，一起探索知识～

题目地址：322. 零钱兑换（中等)

标签：数组、动态规划

题目描述：
给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。
计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。
你可以认为每种硬币的数量是无限的。

思路

不了解动态规划的小伙伴，请前往博主的这篇文章对动态规划做一个初步入门。LeeCode 509-斐波那契数（动态规划入门），记住动态规划的三板斧即可：

• 最优子结构（存在并找到最优子结构才能计算原问题的最值）
• 状态转移方程（解决问题的核心）
• 重叠子问题（采用暴力穷举的方法，效率会很低）

题干清晰的提出了最值求解，最少的硬币个数？对于计算机而言，就是把所有的可能全部穷举，再找到硬币数量最少的一个解法。

暴力递归

• 最优子结构：首先要确认该题是存在最优子结构的，以题目中的例子一为参考，要找到和为11的最少硬币，可以转移至找到和为10，9，6最少硬币数的子问题上，如果知道这了这三个子问题的答案，那么数量加1（在加上一枚1/2/5），这些子问题的最小值就是最少数量硬币和为11的答案。而背包中硬币的数量又是无限的，所以每个子问题之间没有牵制，是独立的个体。
• 状态 转移 方程：
• • 状态： 硬币数量无限，每个硬币的面值是固定的，每次子问题变化的其实是amount，也就是每次求解子问题的目标金额。
• • 转移：目标金额为什么会转移？因为每次选择硬币后，下一次子问题的求和金额就会变化。
• • 方程：本节研讨暴力递归，因此是从上至下的转移，因此定义一个dp（amount），amount就是每次子问题就和的目标amount。

根据上述分析，js代码如下：（注释详解）

/**
 * @param {number[]} coins
 * @param {number} amount
 * @return {number}
 */
var coinChange = function(coins, amount) {
    return dp(coins,amount)
};
const dp = (coins,amount) =>{
    // 目标金额为0时，不需硬币，此分支凑出答案
    if(amount===0){
        return 0
    }
    // 剪到最后，无法正好凑出答案，即此分支子问题无解，返回-1
    if(amount < 0){
        return -1
    }
    // 初实化最大值答案，避免之后小于求解子问题最小值（最大不会超过金额+1，因为全是1的硬币也只需要amount个）
    let res = amount+1
    for(let coin of coins){  
        // 求子问题  
        let sub = dp(coins,amount-coin)
        if(sub !== -1){
            // 存在子问题，则+1，选择最优子问题，
            //这里加一的问题，上文已经提到了，因为将问题分解时，就是原问题 = 子问题 +1 （这个1是1个硬币）
            res = Math.min(sub+1,res)
        }
    }
    return res === amount+1 ? -1: res
}

尝试复制的小伙伴可能发现了上面的代码无法通过测试，这是因为暴力解法存在重叠子问题其实这与斐波那契数是一个道理：

我们可以通过这个树结构发现，这个暴力递归算法的时间复杂度是指数级别的，因此我们需要进行剪枝操作。

优化-剪枝

与之前斐波那契数列类似，只需要稍加修改，就可以通过memory消除子问题：

/**
 * @param {number[]} coins
 * @param {number} amount
 * @return {number}
 */
var coinChange = function(coins, amount) {
    //初始值保证不再解集即可，仅作为子问题是否求解过的flag
    let memory = new Array(amount+1).fill(-6)
    return dp(memory,coins,amount)
};
const dp = (memory,coins,amount) =>{
    // 目标金额为0时，不需硬币，此分支凑出答案
    if(amount===0){
        return 0
    }
    // 剪到最后，无法正好凑出答案，即此分支子问题无解，返回-1
    if(amount < 0){
        return -1
    }
    // 如果该子问题已经求解过，则直接返回
    if(memory[amount] !== -6){
        return memory[amount]
    }
    // 初实化最大值答案，避免之后小于求解子问题最小值（最大不会超过金额+1，因为全是1的硬币也只需要amount个）
    let res = amount+1
    for(let coin of coins){  
        // 求子问题  
        let sub = dp(memory,coins,amount-coin)
        if(sub !== -1){
            // 存在子问题，则+1，选择最优子问题，
            //这里加一的问题，上文已经提到了，因为将问题分解时，就是原问题 = 子问题 +1 （这个1是1个硬币）
            res = Math.min(sub+1,res)
        }
    }
    //记录子问题的值
     memory[amount] =(res == amount+1) ? -1 : res
    return memory[amount]
}

• 时间复杂度：显然子问题的个数不会超过amount（全是面值1的硬币也只需要amount个），处理一个子问题的时间也知识coins的数量(n)，因此时间复杂度为O(amount*n),较之前的指数级大大减小，也可以通过leecode的测试了。

迭代推解

可以自顶向下递归，自然也可以自底向上迭代推解，思路也是类似的，都是将amount作为转移的变量，详看js代码：

var coinChange = function(coins,amount) {  
    let dp = new Array(amount+1).fill(amount + 1);
    // 基础的边界值
    dp[0] = 0;
    // 遍历整个dp数组，找到所有节点的所有可能解
    for (let i = 0; i < dp.length; i++) {
        // 内层迭代找出最小解
        for (let j = 0; j < coins.length; j++) {
            // 子问题可能有解则继续
            if (i - coins[j] >= 0) {
               dp[i] = Math.min(dp[i], 1 + dp[i - coins[j]]);
            }
        }
    }
    return (dp[amount] == amount + 1) ? -1 : dp[amount];
};

小结

其实无论是斐波那契数列，还是最小硬币数量，都是计算机穷举的过程，难点就在于找出状态转移方程，之后如何消除重叠子问题也就迎刃而解了，memory其实也就是空间换时间的经典做法，所有的一切都是你可以列出暴力递归之后的优化，因此可不要小瞧了自上而下的暴力递归。

博主是前大厂程序猿，不定期分享前端知识与算法。

• 公众号：FE Corner
• wx小程序：FE Corner
  欢迎关注，一起探索知识～