码迷,mamicode.com
首页 > 其他好文 > 详细

动态规划——详解leetcode518 零钱兑换 II

时间:2020-07-20 23:02:16      阅读:148      评论:0      收藏:0      [点我收藏+]

标签:process   严格   时间   while   ==   int   res   list   额的   

动态规划 零钱兑换 II

参考书目:《程序员代码面试指南:IT名企算法与数据结构题目最优解》

给定不同面额的硬币和一个总金额。写出函数来计算可以凑成总金额的硬币组合数。假设每一种面额的硬币有无限个。

示例 1:

输入: amount = 5, coins = [1, 2, 5]
输出: 4
解释: 有四种方式可以凑成总金额:
5=5
5=2+2+1
5=2+1+1+1
5=1+1+1+1+1
示例 2:

输入: amount = 3, coins = [2]
输出: 0
解释: 只用面额2的硬币不能凑成总金额3。
示例 3:

输入: amount = 10, coins = [10]
输出: 1

注意:

你可以假设:

0 <= amount (总金额) <= 5000
1 <= coin (硬币面额) <= 5000
硬币种类不超过 500 种
结果符合 32 位符号整数

来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/coin-change-2
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

1. 暴力递归

class Solution(object):
    def change(self, amount, coins):
        """
        :type amount: int
        :type coins: List[int]
        :rtype: int
        """
        if amount == 0:
            return 1
        if not coins or amount < 0:
            return 0
        return self.process(coins, 0, amount)
    
    def process(self, coins, index, amount):
        res = 0
        if index == len(coins):
            return 1 if amount == 0 else 0
        else:
            i = 0
            while coins[index] * i <= amount:
                res += self.process(coins, index+1, amount - i*coins[index])
                i += 1
        return res

暴力递归方法的时间复杂度非常高,并且与 arr 中钱的面值有关,最差情况下为O(amountN

2. 记忆化搜索

# 用-1标记是否计算过
class Solution(object):
    def change(self, amount, coins):
        """
        :type amount: int
        :type coins: List[int]
        :rtype: int
        """
        if amount == 0:
            return 1
        if not coins or amount < 0:
            return 0
        coin_num = len(coins)
        counts = [[0 for i in range(amount+1)] for j in range(coin_num+1)] 
        return self.process(coins, 0, amount, counts)
    
    def process(self, coins, index, amount, counts):
        res = 0
        if index == len(coins):
            return 1 if amount == 0 else 0
        else:
            i = 0
            while coins[index]*i <= amount:
                value = counts[index+1][amount-coins[index]*i]
                if value != 0:
                    res += 0 if value == -1 else value
                else:
                	res += self.process(coins, index+1, amount-coins[index]*i, counts)
                i += 1
       	counts[index][amount] = -1 if res == 0 else res
    	return res

记忆化搜索方法的时间复杂度为 O(N×amount2)

# 超时代码;未标记是否计算过。
class Solution(object):
    def change(self, amount, coins):
        """
        :type amount: int
        :type coins: List[int]
        :rtype: int
        """
        if amount == 0:
            return 1
        if not coins or amount < 0:
            return 0
        coin_num = len(coins)
        counts = [[0 for i in range(amount+1)] for j in range(coin_num+1)] 
        return self.process(coins, 0, amount, counts)
    
    def process(self, coins, index, amount, counts):
        res = 0
        if index == len(coins):
            return 1 if amount == 0 else 0
        else:
            i = 0
            while coins[index]*i <= amount:
                value = counts[index+1][amount-coins[index]*i]
                if value != 0:
                    res += value
                else:
                	res += self.process(coins, index+1, amount-coins[index]*i, counts)
                i += 1
        counts[index][amount] = res
    	return res

3. 动态规划方法

时间复杂度为 O(N×amount2

class Solution(object):
    def change(self, amount, coins):
        """
        :type amount: int
        :type coins: List[int]
        :rtype: int
        """
        if amount == 0:
            return 1
        if not coins or amount < 0:
            return 0
        return self.process(coins, amount)
    
    def process(self, coins, amount):
        counts = [[0 for i in range(amount+1)] for j in range(len(coins)+1)]
        for i in range(len(coins)):
            counts[i][0] = 1
        j = 0
        while coins[0]*j <= amount:
            counts[0][coins[0]*j] = 1
            j += 1
        for i in range(1, len(coins)):
            for j in range(1, amount+1):
                num = 0
                k = 0
                while coins[i]*k <= j:
                    num += counts[i-1][j-coins[i]*k] 
                    k += 1
                counts[i][j] = num
        return counts[len(coins)-1][amount]
        

记忆化搜索的方法说白了就是不关心到达某一个递归过程的路径,只是单纯地对计算过的递归过程进行记录,避免重复的递归过程,而动态规划的方法则是规定好每一个递归过程的计算顺序,依次进行计算,后计算的过程严格依赖前面计算过的过程。

4. 进一步优化的动态规划算法

时间复杂度O(N×amount)

class Solution(object):
    def change(self, amount, coins):
        """
        :type amount: int
        :type coins: List[int]
        :rtype: int
        """
        if amount == 0:
            return 1
        if not coins or amount < 0:
            return 0
        return self.process(coins, amount)
    
    def process(self, coins, amount):
        counts = [[0 for i in range(amount+1)] for j in range(len(coins)+1)]
        for i in range(len(coins)):
            counts[i][0] = 1
        j = 0
        while coins[0]*j <= amount:
            counts[0][coins[0]*j] = 1
            j += 1
        for i in range(1, len(coins)):
            for j in range(1, amount+1):
                counts[i][j] = counts[i-1][j]
                counts[i][j] += counts[i][j-coins[i]] if j - coins[i] >= 0 else 0 # 简化为dp[i][j]=dp[i-1][j]+dp[i][j-arr[i]]。一下省去了枚举的过程,时间复杂度也减小至O(N×amount)
        return counts[len(coins)-1][amount]

5. 对空间进一步优化

class Solution(object):
    def change(self, amount, coins):
        """
        :type amount: int
        :type coins: List[int]
        :rtype: int
        """
        if amount == 0:
            return 1
        if not coins or amount < 0:
            return 0
        return self.process(coins, amount)
    
    def process(self, coins, amount):
        counts = [0 for i in range(amount+1)]
        j = 0
        while coins[0]*j <= amount:
            counts[coins[0]*j] = 1
            j += 1
        for i in range(1, len(coins)):
            for j in range(1, amount+1):
                counts[j] += counts[j-coins[i]] if j - coins[i] >= 0 else 0 # 空间压缩
        return counts[amount]

时间复杂度为O(N×aim)、额外空间复杂度O(aim)的方法。

动态规划——详解leetcode518 零钱兑换 II

标签:process   严格   时间   while   ==   int   res   list   额的   

原文地址:https://www.cnblogs.com/qiangz/p/13346641.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!