代码随想录Day 37|Leetcode|Python|● 1049. 最后一块石头的重量 II ● 494. 目标和 ● 474.一和零

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

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。

每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

• 如果 x == y，那么两块石头都会被完全粉碎；
• 如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。

最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。

解题思路：

本题思路和零一背包的一维问题相似，将stones尽量分成两个大小类似的list，然后相抵消，所以计算出stones之和再除以2，使用数组填充得到sum//2

1. 确定dp数组（dp table）以及下标的含义：dp[i]容量为i时最大容量
2. 确定递推公式：dp[i] = max(dp[i], dp[i-stones[i]]+stones[i])
3. dp数组如何初始化：dp[0]= 0
4. 确定遍历顺序：从后向前，从容量为target开始遍历
5. 举例推导dp数组

class Solution:
    def lastStoneWeightII(self, stones: List[int]) -> int:
        # 确定dp数组（dp table）以及下标的含义
        # 确定递推公式
        # dp数组如何初始化
        # 确定遍历顺序
        # 举例推导dp数组
        target = sum(stones)//2
        dp = [0]*(target+1)
        for i in range(len(stones)):
            for j in range(target, stones[i]-1, -1):
                dp[j] = max(dp[j], dp[j-stones[i]]+stones[i])
        left_sum = sum(stones) - dp[target]
        return abs(dp[target] - left_sum)

 494. 目标和 

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

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

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

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

解题思路：

本题进行零一背包问题转换，分为两个子集，加号子集，减号子集。

add + minus = sum

add - minus = target

minus = sum - add

add - (sum - add) = target

add = (target + sum)//2

现在问题变成：使用数组中的数字装满大小为add的背包，有多少种方法？

1. 确定dp数组（dp table）以及下标的含义：dp[i]当容量为i时有dp[i]种方法
2. 确定递推公式：dp[j] += dp[j-nums[i]]
3. dp数组如何初始化：dp[0] = 1
4. 确定遍历顺序：后序遍历
5. 举例推导dp数组

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

 474.一和零  

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

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

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

解题思路：

1. 确定dp数组（dp table）以及下标的含义：dp[i][j]当容量为i个0，j个1时最大子集的长度
2. 确定递推公式：dp[i][j] = max(dp[i][j], dp[i-x][j-y]+1)，x表示当前string里0的个数，y表示1的个数
3. dp数组如何初始化：dp[0][0] = 0
4. 确定遍历顺序：从后向前
5. 举例推导dp数组

这里要注意m，n的含义，以及在for loop遍历时i，j所对应意义：i对应0的个数，j对应1的个数，有三层循环，第一层是遍历物品即string，第二层是遍历能装0的最大string个数，第三层是遍历能装1的最大string个数，后面两层都是后序遍历，一直到容积为当前最大即zero_num-1和one_num+1为止，更新dp时最重要是理解dp[i-zero_num][j-one_num]+1，即放入当前数后的子串长。

class Solution:
    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
        # 确定dp数组（dp table）以及下标的含义：dp[i][j]当容量为i个0，j个1时最大子集的长度
        # 确定递推公式：dp[i][j] = max(dp[i][j], dp[i-x][j-y]+1)，x表示当前string里0的个数，y表示1的个数
        # dp数组如何初始化：dp[0][0] = 0
        # 确定遍历顺序：从后向前
        # 举例推导dp数组
        dp = [[0]*(n+1) for _ in range(m+1)]
        dp[0][0] = 0
        for string in strs:
            zero_num = string.count('0')
            one_num = len(string) - zero_num
            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]