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

最新推荐文章于 2024-09-28 10:34:40 发布

在下小zhan

最新推荐文章于 2024-09-28 10:34:40 发布

阅读量94

点赞数

分类专栏： leetcode 文章标签： leetcode

本文链接：https://blog.csdn.net/m0_66462858/article/details/134204142

版权

leetcode 专栏收录该内容

51 篇文章 0 订阅

订阅专栏

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

力扣题目链接(opens new window)

题目难度：中等

有一堆石头，每块石头的重量都是正整数。

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

如果 x == y，那么两块石头都会被完全粉碎；

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

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

示例：

输入：[2,7,4,1,8,1]
输出：1

解释：

组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]，
组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]，
组合 2 和 1，得到 1，所以数组转化为 [1,1,1]，
组合 1 和 1，得到 0，所以数组转化为 [1]，这就是最优值。

提示：

1 <= stones.length <= 30
1 <= stones[i] <= 1000

问题转化：
- 将问题转化为背包问题，即尝试将石头放入一个最大容量为所有石头总重量一半的背包中，目的是使背包中的石头总重量最大。
- 这是因为如果我们可以使一堆石头的重量接近总重量的一半，那么另一堆石头的重量也将会非常接近这个值，从而使得最终剩余的石头重量（即两堆石头重量差）最小。
动态规划表的定义：
- 创建一个布尔型的DP表 dp[i][j]，其中 i 表示考虑前 i 个石头，j 表示背包的当前重量。
- dp[i][j] 表示能否用前 i 个石头填满重量为 j 的背包。
初始化：
- dp[0][0] 应该为 true，因为没有石头时背包重量为0是可能的。
- 其他 dp[0][j] （j > 0）应该为 false，因为没有石头无法填满任何非零重量。
状态转移方程：
- 对于每个石头 stones[i] 和每个可能的重量 j：
  - 如果 j < stones[i]，则 dp[i][j] = dp[i-1][j]，因为当前石头太重，无法加入背包。
  - 如果 j >= stones[i]，则 dp[i][j] = dp[i-1][j] || dp[i-1][j-stones[i]]，意味着我们可以选择不放入当前石头，或者放入当前石头，如果放入则需要检查剩余重量（j-stones[i]）能否被前面的石头填满。
填充动态规划表：
- 按照状态转移方程填充DP表。
寻找答案：
- 从 dp[n][j] 开始，n 是石头的数量，j 是背包的最大容量（即所有石头总重量的一半）。
- 从 j 开始向下寻找第一个 dp[n][j] 为 true 的 j，这表示最大能够达到的重量。
- 最后用总重量减去两倍的 j 就会得到最小的可能重量差。
优化空间复杂度：
- 实际实现中，可以只使用一维DP数组来减少空间复杂度，因为每个状态只依赖于前一个状态。
- 更新时从右向左更新，这样可以确保每次更新 dp[j] 时，dp[j-stones[i]] 仍然是上一个状态的值。

通过上述步骤，我们可以高效地找到一个最优解，即最后剩下的石头的最小可能重量。这个问题考验了对动态规划背包问题的理解与应用。

class Solution:
    def lastStoneWeightII(self, stones: List[int]) -> int:
        # 计算所有石头的总重量
        total_weight = sum(stones)
        # 背包容量为总重量的一半
        half_weight = total_weight // 2
        
        # 创建一维DP数组，初始化为0
        dp = [0] * (half_weight + 1)
        
        # 动态规划填充DP数组
        for weight in stones:
            # 从右向左更新，以便复用上一行的结果
            for j in range(half_weight, weight - 1, -1):
                # 状态转移方程
                dp[j] = max(dp[j], dp[j - weight] + weight)
        
        # 最终DP数组的最后一个元素是最接近总重量一半的重量
        # 总重量减去两倍的这个重量即为最小差
        return total_weight - 2 * dp[half_weight]

494.目标和

力扣题目链接(opens new window)

难度：中等

给定一个非负整数数组，a1, a2, ..., an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。

返回可以使最终数组和为目标数 S 的所有添加符号的方法数。

示例：

输入：nums: [1, 1, 1, 1, 1], S: 3
输出：5

解释：

-1+1+1+1+1 = 3
+1-1+1+1+1 = 3
+1+1-1+1+1 = 3
+1+1+1-1+1 = 3
+1+1+1+1-1 = 3

一共有5种方法让最终目标和为3。

提示：

数组非空，且长度不会超过 20 。
初始的数组的和不会超过 1000 。
保证返回的最终结果能被 32 位整数存下。

首先，题目给定了一个非负整数数组和一个目标数S。可以给数组中的每个数字前面加上"+“或者”-"号，目的是使得整个数组的和等于目标数S。

问题要求的是计算有多少种不同的方法可以达到目标数S。

解题思路的转化

这个问题可以转化为找出数组的两个子集，子集P中的数字前面加上"+“号，子集N中的数字前面加上”-"号。如果我们找到了这样的两个子集，使得他们的总和差等于S（即sum§ - sum(N) = S），我们就找到了一种方法。

因为整个数组的总和是sum(nums)，所以我们有 sum§ + sum(N) + sum§ - sum(N) = sum(nums) + S。这意味着2 * sum§ = sum(nums) + S。因此，我们可以将问题转化为：找出数组的一个子集P，使得sum§ = (sum(nums) + S) / 2。

动态规划

可以使用动态规划来解决这个子集和问题。创建一个数组dp，其中dp[i]表示数组nums中的数字能否组成和为i的子集。我们的目标是填充这个数组，最终找到dp[target]的值，其中target是(sum(nums) + S) / 2。

初始化

我们初始化dp[0] = 1，因为不管nums中的数字如何，我们总是可以选择空集来得到和为0。

状态转移方程

我们遍历数组nums中的每个数字num，并更新dp数组。对于每个数字num，我们从target开始遍历到num（包括num），更新dp[i] = dp[i] + dp[i - num]。这样做的原因是：如果存在一个子集的和为i-num，那么加上num之后，这个子集的和就变成了i。

class Solution:
    def findTargetSumWays(self, nums: List[int], target: int) -> int:
        total_sum = sum(nums)  # 计算nums的总和
        if abs(target) > total_sum:
            return 0  # 此时没有方案
        if (target + total_sum) % 2 == 1:
            return 0  # 此时没有方案
        target_sum = (target + total_sum) // 2  # 目标和

        # 创建二维动态规划数组，行表示选取的元素数量，列表示累加和
        dp = [[0] * (target_sum + 1) for _ in range(len(nums) + 1)]

        # 初始化状态
        dp[0][0] = 1

        # 动态规划过程
        for i in range(1, len(nums) + 1):
            for j in range(target_sum + 1):
                dp[i][j] = dp[i - 1][j]  # 不选取当前元素
                if j >= nums[i - 1]:
                    dp[i][j] += dp[i - 1][j - nums[i - 1]]  # 选取当前元素

        return dp[len(nums)][target_sum]  # 返回达到目标和的方案数

474.一和零

力扣题目链接

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

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

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

示例 1：

输入：strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3
输出：4
解释：最多有 5 个 0 和 3 个 1 的最大子集是 {"10","0001","1","0"} ，因此答案是 4 。其他满足题意但较小的子集包括 {"0001","1"} 和 {"10","1","0"} 。{"111001"} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。

示例 2：

输入：strs = ["10", "0", "1"], m = 1, n = 1
输出：2
解释：最大的子集是 {"0", "1"} ，所以答案是 2 。

提示：

1 <= strs.length <= 600
1 <= strs[i].length <= 100
strs[i] 仅由 '0' 和 '1' 组成
1 <= m, n <= 100

class Solution:
    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
        dp = [[0] * (n + 1) for _ in range(m + 1)]  # 创建二维动态规划数组，初始化为0
        for s in strs:  # 遍历物品
            zeroNum = s.count('0')  # 统计0的个数
            oneNum = len(s) - zeroNum  # 统计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]