代码随想录 Day-43｜#1049 最后一块石头的重量II｜#494目标和｜#474 一和零

清单

● 1049. 最后一块石头的重量 II
● 494. 目标和
● 474.一和零

LeetCode #1049 最后一块石头的重量 II

1. 题目

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。
每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：
如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。

2. 思路

1. dp数组的含义: 背包能背的最大重量为dp[i]
2. 递推公式: dp[i] = max( dp[i], dp[i - stone] + stone)
3. 初始化数组: dp = [0] * (target + 1)
4. 遍历顺序: 倒序

3. 代码实现

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

LeetCode #494 目标和

1. 题目

给你一个非负整数数组 nums 和一个整数 target。
向数组中的每个整数前添加 ‘+’ 或 ‘-’ ，然后串联起所有整数，可以构造一个 表达式 ：
例如，nums = [2, 1] ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串联起来得到表达式 “+2-1” 。
返回可以通过上述方法构造的、运算结果等于 target 的不同表达式的数目

2. 思路

target = 正数和 - 负数和 —> sum = 正数和 + 负数和 —> 正数和 = (sum + target) / 2
若正数和 > sum ----> 没有结果/ abs(target) > sum —> 没有结果

1. dp数组含义: 装满i，有dp[i]种方法
2. 递推公式: dp[j] += dp[ j - nums[i]]
3. 初始化: dp[0] = 1
4. 遍历顺序: 正序遍历

3. 代码实现

class Solution:
    def findTargetSumWays(self, nums: List[int], target: int) -> int:
        total_sum = sum(nums)
        if abs(target) > total_sum:
            return 0

        if (target + total_sum) % 2 == 1:
            return 0
        target_sum = (total_sum + target) // 2
        dp = [0] * (target_sum + 1)
        #initial
        dp[0] = 1
        for num in nums:
            for i in range(target_sum, num - 1,-1):
                dp[i] += dp[i- num]
        return dp[target_sum]

LeetCode #474 一和零

1. 题目

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。
请你找出并返回 strs 的最大子集的大小，该子集中最多有 m 个 0 和 n 个 1。
如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的子集

2. 思路

1. dp数组含义: 使用二维dp数组分别代表m个0 和 n 个 1
2. 递推公式: dp[i][j] = max(dp[i][j], dp[i - ZeroNum][j - OneNum] + 1)
3. 初始化: dp[i][j] = 0
4. 遍历顺序: 外顺内倒

3. 代码实现

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 strs:
            ZeroNum = i.count('0')
            OneNum = i.count('1')
            for i in range(m, ZeroNum - 1, -1):
                for j in range(n, OneNum - 1, -1):
                    dp[i][j] = max(dp[i][j], dp[i-ZeroNum][j-OneNum] + 1)
        return dp[m][n]