代码随想录算法训练营day45 | 1049. 最后一块石头的重量 II、494. 目标和、474.一和零

1049. 最后一块石头的重量 II

本题将石头分为两堆，即背包重量为sum(stones) // 2

1. 确定dp数组以及下标的含义：dp[j]表示容量为j的背包可以背的最大重量为dp[j]
2. 确定递推公式：dp[j] = max(dp[j], dp[j-stone] + stone)
3. dp数组的初始化：都是正整数，初始化为0即可
4. 确定遍历顺序：双重循环，物品在外层，背包重量在内层倒序遍历
5. 举例推导dp数组

不用加绝对值，因为sum(stones) - dp[-1] 是大于dp[-1]的

class Solution:
    def lastStoneWeightII(self, stones: List[int]) -> int:
        target = sum(stones) // 2
        dp = [0] * (target + 1)
        for stone in stones:
            for j in range(target, stone-1, -1):
                dp[j] = max(dp[j], dp[j-stone] + stone)
        return abs(sum(stones) - dp[-1] - dp[-1])

494. 目标和

本题回溯会超时

如何转化为01背包问题呢？假设加法的总和为x，那么减法对应的总和就是sum - x。所以我们要求的是 x - (sum - x) = target。x = (target + sum) / 2

此时问题就转化为，装满容量为x的背包，有几种方法。

1. 确定dp数组以及下标的含义：dp[j] 表示填满j（包括j）这么大容积的包，有dp[j]种方法
2. 确定递推公式：dp[j] += dp[j - nums[i]]
3. dp数组如何初始化：dp[0] = 1，如果初始化为0，则后续都为0
4. 确定遍历顺序：nums放在外循环，target在内循环，且内循环倒序
5. 举例推导dp数组

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

474.一和零

本题其实是01背包问题！只不过这个背包有两个维度，一个是m 一个是n，而不同长度的字符串就是不同大小的待装物品。

1. 确定dp数组以及下标的含义：dp[i][j]：最多有i个0和j个1的strs的最大子集的大小为dp[i][j]
2. 确定递推公式：dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1)
3. dp数组的初始化：初始化为0
4. 确定遍历顺序：外层遍历物品，内层倒序遍历背包容量即m和n
5. 举例推导dp数组

class Solution:
    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
        dp = [[0] * (n+1) for _ in range(m+1)]
        for string in strs:
            zero_num = 0
            one_num = 0
            for ch in string:
                if ch == '0':
                    zero_num += 1
                else:
                    one_num += 1
            for i in range(m, zero_num-1, -1):
                for j in range(n, one_num-1, -1):
                    dp[i][j] = max(dp[i][j], dp[i-zero_num][j-one_num] + 1)
        return dp[m][n]