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

最新推荐文章于 2024-10-08 10:36:00 发布

暮炊雪

最新推荐文章于 2024-10-08 10:36:00 发布

阅读量1k

点赞数 16

文章标签： leetcode 算法数据结构 c++ 动态规划

本文链接：https://blog.csdn.net/xiaowutongxue666/article/details/141904376

版权

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

题目：

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

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

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

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

示例 1：

输入：stones = [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]，这就是最优值。

示例 2：

输入：stones = [31,26,33,21,40]
输出：5

提示：

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

思路：

这个问题可以通过动态规划来解决。

可以将其视为一个子集划分问题，其中我们试图将石头分成两堆，使得两堆石头的重量差最小。通过这种方式，剩下的最小重量就等于两堆重量的差值。

动态规划思路：

定义状态： 我们定义 dp[j] 表示在可以达到的总重量为 j 的情况下，是否可以通过某些石头的组合实现。
状态转移： 我们遍历每一块石头，并更新 dp 数组。对于每一个石头，我们可以选择要么将其加入当前的组合（即将其重量加入当前的总重量），要么不加入。

因此，对于每一个石头 stone，我们从背包容量 j 从大到小进行遍历（j 必须大于等于 stone），并且更新 dp[j]：

这里 or 表示我们可以选择当前石头或者不选择当前石头。
求解： 我们最终要找的是所有可以达到的总重量 sum，并且我们要找到一个最接近 sum/2 的总重量 j。在这种情况下，剩余的最小重量就是 sum - 2 * j。
初始化： 初始时，dp[0] = true，表示可以用 0 重量的组合（即没有石头）来达到 0 重量。
返回值： 返回 sum - 2 * j 的最小值，其中 j 是所有 dp[j] 为 true 的最大值且 j <= sum/2。

上代码：

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int sum = accumulate(stones.begin(), stones.end(), 0);
        int target = sum / 2;
        vector<bool> dp(target + 1, false);
        dp[0] = true;
        
        for (int stone : stones) {
            for (int j = target; j >= stone; --j) {
                dp[j] = dp[j] || dp[j - stone];
            }
        }
        
        for (int j = target; j >= 0; --j) {
            if (dp[j]) {
                return sum - 2 * j;
            }
        }
        return 0;
    }
};

494. 目标和

题目：

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

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

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

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

示例 1：

输入：nums = [1,1,1,1,1], target = 3
输出：5
解释：一共有 5 种方法让最终目标和为 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
+1 + 1 + 1 + 1 - 1 = 3

示例 2：

输入：nums = [1], target = 1
输出：1

提示：

1 <= nums.length <= 20
0 <= nums[i] <= 1000
0 <= sum(nums[i]) <= 1000
-1000 <= target <= 1000

思路：

这个问题可以转换为一个子集和问题，并通过动态规划来解决。我们需要将数组划分为两个子集，使得一个子集的和为 P，另一个子集的和为 N。问题的目标是找到这样的 P 和 N，使得 P−N=target。

转换问题：

给定的数组总和为 sum，则有： P + N = sum 和： P - N = target

通过这两个公式，我们可以推导出： 2P = target + sum P = (target + sum) / 2

因此，问题就变成了在数组中找到一个子集，使其和为 P。
检查可行性：

为了使得 P 是一个有效的子集和，必须满足以下条件：
- target + sum 必须是偶数。
- P 必须是非负整数（即 P >= 0）。
如果不满足这些条件，则返回 0。
定义状态：

我们定义 dp[j] 表示从数组中选择一些元素，其和恰好为 j 的不同组合数。
状态转移：

遍历数组 nums，对于每个元素 num，我们更新 dp 数组，从后往前遍历： dp[j] = dp[j] + dp[j - num] 这里，dp[j] 的更新是因为我们可以选择 num 来构造和为 j 的组合，或者不选择它。
初始化：

初始时，dp[0] = 1，表示和为 0 的组合数为 1（即不选择任何元素）。
返回值：

最终，我们返回 dp[P]，它代表了构造出和为 P 的不同组合数。

上代码：

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = accumulate(nums.begin(), nums.end(), 0);
        if ((target + sum) % 2 != 0 || sum < abs(target)) {
            return 0;
        }
        int P = (target + sum) / 2;
        vector<int> dp(P + 1, 0);
        dp[0] = 1;

        for (int num : nums) {
            for (int j = P; j >= num; --j) {
                dp[j] += dp[j - num];
            }
        }

        return dp[P];
    }
};

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

思路：

这个问题可以看作是一个二维的 0/1 背包问题，在一个二维数组中，我们既要考虑 0 的数量限制，也要考虑 1 的数量限制。

动态规划思路：

定义状态： 我们定义 dp[i][j] 表示在最多有 i 个 0 和 j 个 1 的情况下，可以选择的最大子集的大小。
状态转移： 遍历每一个字符串 str，计算其包含的 0 和 1 的数量 zeros 和 ones，然后更新动态规划数组 dp。对于每一个 str，从背包容量 m 和 n 开始反向遍历，更新 dp 数组：

这里，dp[i][j] 的更新是因为我们可以选择 str 来增加当前集合的大小，或者不选择它。
初始化： dp[0][0] 初始化为 0，表示在没有 0 和 1 的情况下，最大子集的大小为 0。
返回值： 最终，dp[m][n] 就是我们要求的答案，表示在最多有 m 个 0 和 n 个 1 的情况下，能够选择的最大子集的大小。

上代码：

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
        
        for (const string& str : strs) {
            int zeros = count(str.begin(), str.end(), '0');
            int ones = str.size() - zeros;
            
            for (int i = m; i >= zeros; --i) {
                for (int j = n; j >= ones; --j) {
                    dp[i][j] = max(dp[i][j], dp[i - zeros][j - ones] + 1);
                }
            }
        }
        
        return dp[m][n];
    }
};