March——322.零钱兑换I,II（背包问题）

 

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        #dp[i]表示金额为i需要最少的硬币
        #自顶向下
        #dp[i] = min[dp[i-coin1],dp[i-coin2],dp[i-coin3]]+1
        #在functools这个模块中，有lru_cache这个一个神奇的装饰器存在。
        #functools.lru_cache的作用主要是用来做缓存，他能把相对耗时的函数结果进行保存，避免传入相同的参数重复计算。
        #同时，缓存并不会无限增长，不用的缓存会被释放。
        # import functools
        # @functools.lru_cache(None)
        # def helper(amount):
        #     if amount==0:
        #         return 0
        #     return min(helper(amount-c) if amount-c>=0 else float('inf') for c in coins)+1
        # res = helper(amount)
        # if res!=float('inf'):
        #     return res
        # else:
        #     return -1




        #动态规划，自底向上
        #计算dp[3]之前必须将dp[0],dp[1],dp[2]计算出来
        dp = [float('inf') for _ in range(amount+1)] 
        dp[0] = 0
        for i in range(1,amount+1):
            for coin in coins:
                if i-coin>=0:
                    dp[i] = min(dp[i],dp[i-coin]+1)
            
            #dp[i] = min(dp[i-c] if i-c>=0 else float('inf') for c in coins)+1
        print(dp)
        return  dp[-1] if dp[-1]!=float('inf') else -1

 

• 解题思路
  • 动态规划
    • dp[amount]表示金额amount需要使用最少的硬币
    • dp[amount] = min(dp[amount-coin1],dp[amount-coin2],dp[amount-coin3])+1
  • 自顶向下
    • 就是进行逐层的递归，最终计算结果，只管定义出递归方程即可
  • 自底向上
    • 自底向上进行，先计算dp[0],dp[1]...dp[i-1]
    • 最终返回动态规划的最后一个状态转移方程

总结：一般最大，最小，最多，最少的问题都采用动态规划去进行解决，先将庞大的问题划分成子问题，然后进行求解。

class Solution:
    def change(self, amount: int, coins: List[int]) -> int:

        #用dp[x] 表示金额之和等于x的硬币组合数，目标是求dp[amount]。
        #初始化金额为0的只有1种
        dp = [0]*(amount+1)
        dp[0] = 1
        for coin in coins:
            #每添加一种零钱，总金额的变化
            for j in range(1,amount+1):
                if j>=coin:
                    dp[j]+=dp[j-coin]
            print(dp)
        return dp[-1]