【leetcode-Python】-Dynamic Programming-518. Coin Change 2

最新推荐文章于 2021-03-20 22:06:41 发布

_忽如远行客

最新推荐文章于 2021-03-20 22:06:41 发布

阅读量138

点赞数

分类专栏： leetcode

本文链接：https://blog.csdn.net/gulaixiangjuejue/article/details/113803220

版权

leetcode 专栏收录该内容

90 篇文章 2 订阅

订阅专栏

题目链接

https://leetcode.com/problems/coin-change-2/

题目描述

给定不同面额的硬币和总金额，计算能够凑成总金额的硬币组合数，假设每种面额的硬币有无数个。

示例

输入：amount = 5,coins = [1,2,5]

输出：4

5 = 5

2 + 2 + 1 = 5

2 + 1 + 1 + 1 = 5

1 + 1 +1 + 1 + 1 = 5

解题思路

这道题目是完全背包问题的变体：对于容量为amount的背包和重量为coins[i]的物品(数量为无数个)，有多少种方法可以把背包装满?

在写动态规划算法中的状态转移方程时，labuladong给出了以下几个步骤：

（1）确定base case，写出能直接确定的边缘取值的情况。

（2）确定状态，状态指的是在原问题和子问题中会变化的量。在背包问题里，状态为背包的容量和可以选择的物品。

（3）确定选择，就是导致状态改变的行为。在背包问题里，选择就是“放进背包”和“不放进背包”两种。

（4）确定dp函数或数组的定义。对于当前这个问题，可以用dp[i][j]表示用前i枚硬币，有多少方法可以凑够金额j（用前i个物品，有多少种方法可以把容量为j的背包装满）。

base case为dp[i][0]和dp[0][j]，dp[i][0]表示用前i个硬币凑金额0，那么“不用任何硬币”即可，因此dp[i][0] = 1(表示有一种方法)。由于可用硬币为空，那么凑够金额j的方法数应该为0，因此dp[0][j]=0。

接下来可以由底向上更新dp数组，并最后返回dp[n][amount],其中n = len(coins)。

下面考虑根据不同选择(使用或不使用第i个硬币)更新dp[i][j]需要的状态转移方程。

（1）不使用第i个硬币（面值为coins[i-1]），那么凑出来金额j的方法数就应该等于dp[i-1][j],即使用前i-1个硬币来凑齐金额j的方法数

（2）使用第i个硬币（面值为coins[i-1]），那么凑出来金额j的方法数就应该等于dp[i][j-coins[i-1]]，即在确定会用一个面值为coins[i-1]的硬币后，就只关注用前i个硬币来凑齐金额j-coins[i-1]的方法数。（因为已经决定要有一个面值为coins[i-1]的硬币加入了）

Python实现

class Solution:
    def change(self, amount: int, coins: List[int]) -> int:
        #注意开的数组大小 len(coins)+1行，amount+1列
        dp = [[0 for _ in range(amount+1)] for _ in range(len(coins)+1)]
        dp[0][0] = 1
        for i in range(1,len(coins)+1):
            #base case
            dp[i][0] = 1
            for j in range(1,amount+1):
                dp[i][j] = dp[i-1][j] + (dp[i][j-coins[i-1]] if j >= coins[i-1] else 0)
        return dp[len(coins)][amount]

时间复杂度与空间复杂度

时间复杂度为O(nS)，其中n为coins数组长度，S为amount的值。空间复杂度为O(nS)。

优化-状态压缩

通过状态转移方程发现，dp[i][j]的更新只依赖于dp[i-1][j]（二维数组中的上一行）和dp[i][j-coins[i-1]]（在二维数组中位于dp[i][j]的左侧），我们可以把维度从二维降为一维，由dp[j]表示用前i个硬币凑成金额j的方法，i在外层for循环中被更新。在每次循环中对dp[j]赋值之前，dp[j]的值为在外层for循环中上一次迭代的计算结果，即二维数组中的dp[i-1][j]。因为由amount从小到大的更新顺序决定了dp[j-coins[i]]先更新，dp[j-coins[i]]相当于二维数组中的dp[i][j-coins[i]]。每次迭代更新一维数组dp，相当于是在更新状态压缩前二维数组的每一行。

base case为dp[0] = 1。

令coins = [1,2,5],amout = 5，举例说明计算步骤：

（1）只考虑coins[0],即面值为1的硬币，此时更新dp[0],...dp[amount],也就是仅用面值为1的硬币凑齐金额j的方法数。

（2）新加入coins[1]，考虑coins[0]、coins[1]即面值为1、2的硬币，此时继续更新dp[0],...,dp[amount]，也就是用面值为1和面值为2的硬币凑齐金额j的方法数。更新方式为dp[j] = dp[j] + dp[j-coins[1]],即（不用coins[1]时凑成金额i的方法数）+（使用coins[1]时凑成金额j-coins[1]的方法数），

（3）考虑coins[0]、coins[1]、coins[2]，即把面值为1、2、5的硬币都纳入可选择范围，此时更新dp[0],...,dp[amount],即用面值为1、2、5的硬币凑齐金额j的方法数。最后返回dp[amount]=4即可。

Python实现

class Solution:
    def change(self, amount: int, coins: List[int]) -> int:
        dp = [0 for _ in range(amount + 1)]
        dp[0] = 1
        for coin in coins:
            for j in range(coin,amount+1):
                dp[j] = dp[j] + dp[j-coin]
        return dp[amount]

时间复杂度与空间复杂度

时间复杂度为O(nS)，其中n为coins数组长度，S为amount的值。空间复杂度为O(S)。

拓展

1、在状态压缩的这个解法中，如果双重循环的顺序调换，即改为第一层循环更新amount，第二层循环遍历coins，那么得到的结果会比正确结果大（对于更新二维数组的初始算法，更改内外层循环顺序对结果没有影响）。

比如coins=[2,5],amount = 7。如果第一层循环是遍历amount，第二层循环遍历coins：

（1）amount = 2时，dp[2] = 1。

（2）amount = 5时，dp[5] = 1。

（3）amount = 7时，遍历到coins[0]=2时，dp[7] = dp[7] + dp[5] = 1，即先加入coins[0]，再加入coins[1]。遍历到coins[1] = 5时，dp[7] = dp[7] + dp[2] = 2，即先加入coins[1]，再加入coins[0]。

也就是说，循环嵌套顺序改变后，代码会把2+5和5+2当成不同的方案并计数，因此会将同一硬币集合中硬币的不同排列顺序当作不同的方法，从而出现重复。而原问题是一个组合问题，而不是排列问题。

实际上，循环嵌套顺序改变后，dp[j]的意义就发生了改变，即将所有面值的硬币都考虑在内凑齐金额j的方法数，从0到amount会造成路径重复。

2、在一个问题中，结果的排序是否重要会影响动态规划算法中dp数组的定义。

如果排列顺序很重要（和相等，但是元素排列顺序不同就意味着不同的方案），那么dp[i][j]将被定义为选择范围为所有元素但以nums[i]为结尾的元素组，其和为j的方法数，最后返回dp[i][target]的和（将以不同元素为结尾，和为target的方案数相加，会得到所有排列结果）。寻找和为target的方法数时，需要用到和小于target的方法数。

如果排列顺序不重要，那么dp[i][j]将被定义为选择范围为从nums[0]到当前nums[i]范围的元素（nums[i]可选可不选），其和为j的方法数。可选元素的范围不断扩大。最后返回的结果为（包括nums[-1]的方法数）+（不包括nums[-1]的方法数），在选择时仅考虑元素是否存在，因此不会将不同的排列作为不同的方法来计算。在nums[:]元素范围下寻找和为target的方法数，需要用到更小元素范围内的组合结果。