LeetCode之动态规划背包问题实操

01Pack

# 1600ms
class Solution:
    def canPartition(self, nums):
        sum_total = sum(nums)
        if sum_total % 2:  # 若总为奇数, 则不能被分割成两个子集
            return False
        pack_capcity = sum_total // 2  # 背包大小
        dp = [float('-inf')] * (pack_capcity + 1)
        dp[0] = 0
        for i in range(len(nums)):
            for j in range(pack_capcity, nums[i]-1, -1):
                dp[j] = max(dp[j], dp[j-nums[i]] + nums[i])
                if dp[-1] > 0:  # 剪枝操作,当dp[-1]>0时可以确定存在可行划分... 不剪枝会超时
                    return True
        return False

这道题目也可以用逐个过滤元素的方法来做，先大到小排序以减少过滤次数。

# 56ms
class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        if len(nums) == 0:
            return True
        if sum(nums)%2 == 1:
            return False
        half = sum(nums)//2
        nums.sort(reverse=True)
        def search(target, numlist):
            if len(numlist)==0:
                return False
            if target in numlist:
                return True
            if target<numlist[0]:
                return False
            for i in range(len(numlist)):
                res = search(target-numlist[i], numlist[i+1:])
                if res:
                    return True
            return False
        
        res = search(half, nums)
        return res

将问题转化成01背包问题

这种想法比较巧妙，一开始我也想到用01背包求解，但是不知道怎么处理负数的问题以及如何奇数的问题。我们来看如下例子：

nums = {1,2,3,4,5}, target=3, 一种可行的方案是+1-2+3-4+5 =3

该方案中数组元素可以分为两组，一组是数字符号为正(P={1,3,5})，另一组数字符号为负(N={2,4})

因此: sum(1,3,5) - sum(2,4) = target

sum(1,3,5) - sum(2,4) + sum(1,3,5) + sum(2,4) = target + sum(1,3,5) + sum(2,4)

2sum(1,3,5) = target + sum(1,3,5) + sum(2,4)

2sum(P) = target + sum(nums)

sum(P) = (target + sum(nums)) / 2

由于target和sum(nums)是固定值，因此原始问题转化为求解nums中子集的和等于sum(P)的方案个数问题

class Solution:
    def findTargetSumWays(self, nums, S):
        if sum(nums) < S or (sum(nums) + S) % 2 == 1: return 0
        P = (sum(nums) + S) // 2
        dp = [1] + [0 for _ in range(P)]
        for num in nums:
            for j in range(P, num - 1, -1):
                # dp[i] 的解法数为自身加上dp[i-num]的解法数
                # 这里为什么会如此，可以参考斐波那契数列
                # 这里我可以不放 num 进背包，解法数为 dp[i]
                # 将 num 放进背包，解法数为 dp[i-num]
                # 所以此时的总解法数为 二者和
                dp[j] += dp[j - num]
            # print(dp)
        return dp[P]

完全背包 CompletePack

说明：这个是需要正好装满整个背包，取个数的最小数。状态转移时可以用min来取较小者。

class Solution:
    def coinChange(self, coins, amount):
        dp = [amount + 1] * (amount + 1)
        dp[0] = 0
        for i in range(1, len(coins)+1):
            for j in range(coins[i-1], amount + 1):
                    dp[j] = min(dp[j], dp[j - coins[i-1]]+1)
        return -1 if dp[-1] > amount else dp[-1]

二维01背包问题

class Solution:
    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
        dp = [[0 for _ in range(n+1)] for ii in range(m+1)]
        # dp = [[0]*(n+1) for _ in range(m+1)]   #准备很多个背包
        for one in strs:
            item_count0 = one.count('0')
            item_count1 = one.count('1')
            for i in range(m, item_count0-1, -1):
                for j in range(n, item_count1-1, -1):
                    dp[i][j] = max(dp[i][j], dp[i-item_count0][j-item_count1]+1)
        return dp[m][n]