【算法挨揍日记】day42——494. 目标和、1049. 最后一块石头的重量 II

494. 目标和

494. 目标和

题目描述：

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

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

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

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

解题思路：

算法思路：

本题可以直接⽤「暴搜」的⽅法解决。但是稍微⽤数学知识分析⼀下，就能转化成我们常⻅的「背

包模型」的问题。

设我们最终选取的结果中，前⾯加 + 号的数字之和为 a ，前⾯加 - 号的数字之和为 b ，整个数组

的总和为 sum ，于是我们有：

▪ a + b = sum

▪ a - b = target

上⾯两个式⼦消去 b 之后，可以得到 a = (sum + target) / 2

也就是说，我们仅需在 nums 数组中选择⼀些数，将它们凑成和为 (sum + target) / 2 即

可。

问题就变成了 416. 分割等和⼦集 这道题。

我们可以⽤相同的分析模式，来处理这道题。

1. 状态表⽰：

dp[i][j] 表⽰：在前 i 个数中选，总和正好等于 j ，⼀共有多少种选法。

2. 状态转移⽅程：

⽼规矩，根据「最后⼀个位置」的元素，结合题⽬的要求，我们有「选择」最后⼀个元素或者「不

选择」最后⼀个元素两种策略：

i. 不选 nums[i] ：那么我们凑成总和 j 的总⽅案，就要看在前 i - 1 个元素中选，凑

成总和为 j 的⽅案数。根据状态表⽰，此时 dp[i][j] = dp[i - 1][j] ；

ii. 选择 nums[i] ：这种情况下是有前提条件的，此时的 nums[i] 应该是⼩于等于 j 。

因为如果这个元素都⽐要凑成的总和⼤，选择它就没有意义呀。那么我们能够凑成总和为

j 的⽅案数，就要看在前 i - 1 个元素中选，能否凑成总和为 j - nums[i] 。根据

状态表⽰，此时 dp[i][j] = dp[i - 1][j - nums[i]]

综上所述，两种情况如果存在的话，应该要累加在⼀起。因此，状态转移⽅程为：

dp[i][j] = dp[i - 1][j]

if(nums[i - 1] <= j) dp[i][j] = dp[i][j] += dp[i - 1][j - nums[i

- 1]]

3. 初始化：

由于需要⽤到「上⼀⾏」的数据，因此我们可以先把第⼀⾏初始化。

第⼀⾏表⽰不选择任何元素，要凑成⽬标和 j 。只有当⽬标和为 0 的时候才能做到，因此第⼀

⾏仅需初始化第⼀个元素 dp[0][0] = 1

4. 填表顺序：

根据「状态转移⽅程」，我们需要「从上往下」填写每⼀⾏，每⼀⾏的顺序是「⽆所谓的」。

5. 返回值：

根据「状态表⽰」，返回 dp[n][aim] 的值。

其中 n 表⽰数组的⼤⼩， aim 表⽰要凑的⽬标和。

6. 空间优化：

所有的「背包问题」，都可以进⾏空间上的优化。

对于 01背包类型的，我们的优化策略是：

i. 删掉第⼀维；

ii. 修改第⼆层循环的遍历顺序即可。

解题代码：

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum=0;
        for(auto x : nums) sum += x;
        int a=(sum+target)/2;
        int n=nums.size();
        if(a<0||(sum+target)%2) return 0;
        vector<int>dp(a+1);
        dp[0]=1;
        for(int i=1;i<=n;i++)
        {
            for(int j=a;j>=nums[i-1];j--)
                    dp[j]+=dp[j-nums[i-1]];
        }
        return dp[a];
    }
};

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

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

题目描述：

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

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

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

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

解题思路：

算法思路：

先将问题「转化」成我们熟悉的题型。

▪ 任意两块⽯头在⼀起粉碎，重量相同的部分会被丢掉，重量有差异的部分会被留下来。那就

相当于在原始的数据的前⾯，加上「加号」或者「减号」，是最终的结果最⼩即可。也就是

说把原始的⽯头分成两部分，两部分的和越接近越好。

▪ ⼜因为当所有元素的和固定时，分成的两部分越接近数组「总和的⼀半」，两者的差越⼩。

因此问题就变成了：在数组中选择⼀些数，让这些数的和尽量接近 sum / 2 ，如果把数看成物

品，每个数的值看成体积和价值，问题就变成了「01 背包问题」。

1. 状态表⽰：

dp[i][j] 表⽰在前 i 个元素中选择，总和不超过 j，此时所有元素的「最⼤和」。

2. 状态转移⽅程：

⽼规矩，根据「最后⼀个位置」的元素，结合题⽬的要求，分情况讨论：

i. 不选 stones[i] ：那么我们是否能够凑成总和为 j ，就要看在前 i - 1 个元素中

选，能否凑成总和为 j 。根据状态表⽰，此时 dp[i][j] = dp[i - 1][j] ；

ii. 选择 stones[i] ：这种情况下是有前提条件的，此时的 stones[i] 应该是⼩于等于

j 。因为如果这个元素都⽐要凑成的总和⼤，选择它就没有意义呀。那么我们是否能够凑

成总和为 j ，就要看在前 i - 1 个元素中选，能否凑成总和为 j - stones[i] 。根

据状态表⽰，此时 dp[i][j] = dp[i - 1][j - stones[i]] + stones[i] 。

综上所述，我们要的是最⼤价值。因此，状态转移⽅程为：

dp[i][j] = dp[i - 1][j]

if(j >= stones[i]) dp[i][j] = dp[i][j] + dp[i - 1][j - stones[i]]

+ stones[i] 。

3. 初始化：

由于需要⽤到上⼀⾏的数据，因此我们可以先把第⼀⾏初始化。

第⼀⾏表⽰「没有⽯⼦」。因此想凑成⽬标和 j ，最⼤和都是 0 。

4. 填表顺序：

根据「状态转移⽅程」，我们需要「从上往下」填写每⼀⾏，每⼀⾏的顺序是「⽆所谓的」。

5. 返回值：

a. 根据「状态表⽰」，先找到最接近 sum / 2 的最⼤和 dp[n][sum / 2] ；

b. 因为我们要的是两堆⽯⼦的差，因此返回 sum - 2 * dp[n][sum / 2] 。

6. 空间优化：

所有的背包问题，都可以进⾏「空间」上的优化。

对于 01背包类型的，我们的优化策略是：

i. 删掉第⼀维；

ii. 修改第⼆层循环的「遍历顺序」即可。

解题代码：

class Solution
{
public:
 int lastStoneWeightII(vector<int>& stones) 
 {
 // 1. 准备⼯作
 int sum = 0;
 for(auto x : stones) sum += x;
 int n = stones.size(), m = sum / 2;
 // 2. dp
 vector<int> dp(m + 1);
 for(int i = 1; i <= n; i++)
 for(int j = m; j >= stones[i - 1]; j--)
 dp[j] = max(dp[j], dp[j - stones[i - 1]] + stones[i - 1]);
 // 3. 返回结果
 return sum - 2 * dp[m];
 }
};