24暑假算法刷题 | Day36 | 动态规划 IV 背包问题II | LeetCode 1049. 最后一块石头的重量 II，494. 目标和，474. 一和零

makabaka_T_T

于 2024-08-13 21:22:53 发布

阅读量488

点赞数 24

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

本文链接：https://blog.csdn.net/weixin_54468359/article/details/141170950

版权

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

题解

根据题目，这些石头有点像玩消消乐一样”两两消除“，所以其实我们可以采用整体的思想，将它们尽可能地分成 大小接近的两堆 ，这样两堆各自的重量之和相减，得到的就是最终剩余的那块石头重量（若恰好能分成等重的两堆，则刚好全部消除）。自然，每堆的重量应该尽量接近总重量的一半：

int sumWeight = 0; 
for (int stone : stones)
    sumWeight += stone;
int halfWeight = sumWeight / 2;

接下来，我们要尝试从 stones 中选取若干个元素，使得它们的和靠近 halfWeight 。这就可以把问题转化为 01背包问题 ，再采用相应的 动态规划 方法解决：

有 weights 和 value 都为 stones 的物品，尽可能在容量为 halfWeight 的背包中装价值高的物品。 相应的，有

dp 数组含义： dp[j] 表示容量为 j 的背包能装的最高总价值
状态转移方程： dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]) （常规模式）

最后得到的 dp[halfWeight] 相当于其中一堆的重量（根据01背包算法，已经尽量接近总重量的一半了），另一堆的重量自然就是 sumWeight - dp[halfWeight] 。那么二者之差 abs(sumWeight - 2 * dp[halfWeight]) 即为所求结果。

该算法更详细的解析参见代码随想录

代码（C++）

int lastStoneWeightII(vector<int> &stones)
{
    // 分成两大堆，且尽量使它们重量相等
    int sumWeight = 0; 
    for (int stone : stones)
        sumWeight += stone;
    int halfWeight = sumWeight / 2;
    // 转化为01背包问题：容量为halfWeight的背包
    vector<int> dp(halfWeight + 1, 0);
    for (int j = stones[0]; j <= halfWeight; ++j)
        dp[j] = stones[0];
    for (int i = 1; i < stones.size(); ++i) {
        for (int j = halfWeight; j >= stones[i]; --j)
            dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
    }
    return abs(sumWeight - 2 * dp[halfWeight]);
}

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

题解

这题乍一看就是个组合问题，所以首先无脑尝试了一下回溯算法：

class Solution // 回溯算法
{
private:
    int count = 0;
    void backTracking(const vector<int> &nums, int target, int curSum, int index) {
        // 递归出口：数组中各数都用到了（遍历结束）
        if (index == nums.size()) {
            if (curSum == target) 
                count++;
            return;
        }
        // 添加 "+"
        curSum += nums[index]; // 处理
        backTracking(nums, target, curSum, index + 1); // 递归
        curSum -= nums[index]; // 回溯
        // 添加 "-"
        curSum -= nums[index];
        backTracking(nums, target, curSum, index + 1);
        curSum += nums[index];
    }

public:
    int findTargetSumWays(vector<int> &nums, int target)
    {
        backTracking(nums, target, 0, 0);
        return count;
    }
};

在LeetCode上通过了，但是慢得无与伦比：

（疑似在超时边缘疯狂试探可能换个配置不太好的机器就超时了 😵 ）

考虑其他更优雅高效的算法。根据题目要求，我们最终要将数组中的数一部分取正、另一部分取负。

这里的“取正”和“取负”就是题目中的添加"+“和”-“，所以也要考虑0——虽然给它加”+“还是”-"得到的数值一样，但是组合方式不同

记原数组之和为 $s u m$ ，最终的所有取正的数字之和为 $a dd$ ，则所有取负的数字之和为 $- (s u m - a dd)$ 。二者之和即为 $t a r g e t$ ，即

$a dd - (s u m - a dd) = t a r g e t$

所以

$a dd = (t a r g e t + s u m) /2$

于是，问题变成了 从 nums 中找若干数字、使其和为 $a dd$ 有多少种方法 。根据上面的公式可知， $a dd$ 不能为负数或奇数。

进一步，可以发现这其实能转化为 01背包问题 ：

nums 相当于物品的 weights ，求用这些物品将容量为 add 的背包恰好装满有多少种方法？

那么按照01背包问题的常规动态规划解法就能搞定了，其中

dp 数组的含义： dp[j] 表示恰好装满容量为 j 的背包有 dp[j] 种方法
状态转移方程：对于容量为 j 的背包，现考虑一个新的物品 i ，若把它放进背包能恰好装满，则放之前的背包状态的实现方法有 dp[j - weights[i]] （即 dp[j - nums[i]] ）种。所以，此时就新增了这么多种方法，即 dp[j] += dp[j - nums[i]]

代码（C++）

int findTargetSumWays(vector<int> &nums, int target)
{
    int sum = 0;
    for (int num : nums)
        sum += num;
    if ((target + sum) < 0 || (target + sum) % 2 == 1)
        return 0;
    int add = (target + sum) / 2;
    // 背包问题：nums相当于weights，求装满容量为add的背包有多少种方法
    vector<int> dp(add + 1);
    dp[0] = 1;
    // 若有新的物品i，要装满容量为j的背包，则又新增dp[j - nums[i]]中方法
    for (int i = 0; i < nums.size(); ++i) {
        for (int j = add; j >= nums[i]; --j)
            dp[j] += dp[j - nums[i]];
    }
    return dp[add];
}

这个算法就高效多了：

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

题解

实际上是01背包的变形（多了一个维度），动态规划解决。

最基本的01背包对应的物品只有“重量”和“价值”，背包自身的限制只有一个 “容量”，但是本题中，很显然，类似“容量”的值有两个： m 和 n ，可以分别理解为背包能装的 0 和 1 的容量。那么直接按照常规背包的解决方案，多加一层循环以便处理两个维度的 weights 和”容量“即可：

dp 数组含义： dp[i][j] 表示容量为 i 个 0 和 j 个 1 的背包中，最多能装的元素个数（也就是题目中的子集大小）
状态转移方程： dp[i][j] = max(dp[i][j], dp[i - zeroCount][j - oneCount] + 1) ，其中 zeroCount 和 oneCount 表示当前处理的字符串中 0 和 1 的个数； + 1 相当于在原来那个子集中加入当前处理的字符串

该算法更详细的解析参见代码随想录

C++

int findMaxForm(vector<string> &strs, int m, int n)
{
    // dp[i][j]: 最多有i个0和j个1的子集的最大长度
    // 对于新的二进制字符串k，其中0和1数量为k_0和k_1:
    // dp[i][j] = max(dp[i][j], dp[i - k_0][j - k_1] + 1)
    vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
    for (const string &str : strs) {
        int zeroCount = count(str.begin(), str.end(), '0');
        int oneCount = count(str.begin(), str.end(), '1');
        for (int i = m; i >= zeroCount; --i) {
            for (int j = n; j >= oneCount; --j) 
                dp[i][j] = max(dp[i][j], dp[i - zeroCount][j - oneCount] + 1);
        }
    }
    return dp[m][n];
}

Golang

func findMaxForm(strs []string, m int, n int) int {
	dp := make([][]int, m+1)
	for i := 0; i <= m; i++ {
		dp[i] = make([]int, n+1)
	}
	for _, str := range strs {
		zeroCount, oneCount := 0, 0
		for _, c := range str {
			if c == '0' {
				zeroCount++
			}
			if c == '1' {
				oneCount++
			}
		}
		for i := m; i >= zeroCount; i-- {
			for j := n; j >= oneCount; j-- {
				dp[i][j] = max(dp[i][j], dp[i-zeroCount][j-oneCount]+1)
			}
		}
	}
	return dp[m][n]
}

Python

class Solution(object):
    def findMaxForm(self, strs, m, n):
        """
        :type strs: List[str]
        :type m: int
        :type n: int
        :rtype: int
        """
        dp = [[0] * (n + 1) for _ in range(m + 1)]
        for str in strs:
            zero_count = str.count('0')
            one_count = str.count('1')
            for i in range(m, zero_count - 1, -1):
                for j in range(n, one_count - 1, -1):
                    dp[i][j] = max(dp[i][j], dp[i - zero_count][j - one_count] + 1)
        return dp[m][n]

makabaka_T_T

关注

24
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
24暑假算法刷题 | Day36 | 动态规划 IV 背包问题II | LeetCode 1049. 最后一块石头的重量 II，494. 目标和，474. 一和零

day36打卡：动态规划 IV 背包问题 II
复制链接

扫一扫