2024.08.05 代码随想录 ｜ 动态规划 背包问题

494.目标和

给你一个非负整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ：

• 例如，nums = [2, 1] ，可以在 2 之前添加 '+' ，在 1 之前添加 '-' ，然后串联起来得到表达式 "+2-1" 。

返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

转化为背包问题：

假设符号取'+'的整数和为x, 则符号取'-'的整数和为sum(nums)-x

要达到target，则x-(sum(nums)-x) = target，即要使得x = ( target + sum(nums))//2

此时bagweight = ( target + sum(nums))//2

dp[i][j]表示从0-i物品中任取，刚好装满承重为j的背包的取法有几种

二维解法：
这里的区别在于dp[0][j]表示不取任何物品时使得质量为j的取法，dp[i+1][j]表示从nums[0]到nums[1]任取时使得质量为j的取法。为什么要这样？因为dp[1][j]无法直接通过人为的统一设置来确定，必须通过dp[0][j]来获得

class Solution:
    def findTargetSumWays(self, nums: List[int], target: int) -> int:
        if (sum(nums) + target) % 2 != 0:
            return 0
        if target > sum(nums) or target < -sum(nums):
            return 0
        bagweight = (sum(nums) + target) // 2
        dp = [[0] * (bagweight + 1) for _ in range(len(nums) + 1)]
        dp[0][0] = 1
        for i in range(1, len(nums) + 1):
            for j in range(bagweight + 1):
                if j < nums[i-1]:
                    dp[i][j] = dp[i - 1][j]
                else:
                    dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i-1]]
        return dp[-1][-1]

一维解法：

class Solution:
    def findTargetSumWays(self, nums: List[int], target: int) -> int:
        if (sum(nums) + target) % 2 != 0:
            return 0
        if target > sum(nums) or target < -sum(nums):
            return 0
        bagweight = (sum(nums) + target) // 2
        dp = [0] * (bagweight + 1)
        dp[0] = 1
        for i in range(len(nums)):
            for j in range(bagweight, nums[i]-1, -1):
                dp[j] += dp[j-nums[i]]
        
        return dp[-1]
        

474.一和零

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的长度，该子集中 最多 有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。

这一题其实是背包容量为二维的01背包问题

class Solution:
    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
        dp = [[0] * (n+1) for _ in range(m+1)]
        for i in range(len(strs)):
            zeoro_num = strs[i].count("0")
            one_num = len(strs[i]) - zeoro_num
            for j in range(m, zeoro_num-1, -1):
                for k in range(n, one_num-1, -1):
                    dp[j][k] = max(dp[j][k], dp[j-zeoro_num][k-one_num] + 1)
        return dp[m][n]

 完全背包问题

有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品都有无限个（也就是可以放入背包多次），求解将哪些物品装入背包里物品价值总和最大。

注意：

1. 这里跟01背包的区别就是，遍历背包容量的时候不需要从大到小，之前需要从大到小是为了避免一个物品重复放入，完全背包可以重复放入，因此遍历背包容量的时候就要从小到大。

2. 完全背包问题可以交换两个for的顺序，01背包中二维dp数组的两个for遍历的先后循序也可以颠倒，但一维dp数组的两个for循环先后循序一定是先遍历物品，再遍历背包容量。

因为dp[j] 是根据 下标j之前所对应的dp[j]计算出来的。 只要保证下标j之前的dp[j]都是经过计算的就可以了。

def test_CompletePack():
    weight = [1, 3, 4]
    value = [15, 20, 30]
    bagWeight = 4
    dp = [0] * (bagWeight + 1)
    for i in range(len(weight)):  # 遍历物品
        for j in range(weight[i], bagWeight + 1):  # 遍历背包容量
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
    print(dp[bagWeight])

test_CompletePack()

def test_CompletePack():
    weight = [1, 3, 4]
    value = [15, 20, 30]
    bagWeight = 4

    dp = [0] * (bagWeight + 1)

    for j in range(bagWeight + 1):  # 遍历背包容量
        for i in range(len(weight)):  # 遍历物品
            if j - weight[i] >= 0:
                dp[j] = max(dp[j], dp[j - weight[i]] + value[i])

    print(dp[bagWeight])

test_CompletePack()

 518.零钱兑换II

给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。

请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。

假设每一种面额的硬币有无限个。 

题目数据保证结果符合 32 位带符号整数。

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

377. 组合总和 Ⅳ

如果求组合数就是外层for循环遍历物品，内层for遍历背包。

如果求排列数就是外层for遍历背包，内层for循环遍历物品。

注意：

如果求放入背包价值最大，无所谓排列还是组合，两个for循环可以颠倒顺序。

如果求放入背包的方法则有排列和组合之分，for循环的顺序得分情况考虑

class Solution:
    def combinationSum4(self, nums: List[int], target: int) -> int:
        dp = [0] * (target+1)
        dp[0] = 1
        for j in range(target + 1):
            for num in nums:
                if j >= num:
                    dp[j] += dp[j-num]
        return dp[target]