【代码随想录训练营第42期 Day36打卡 - 动态规划Part4 - LeetCode 1049. 最后一块石头的重量 II 494. 目标和 474.一和零-CSDN博客

有一堆石头，用整数数组 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

题解：动态规划--01背包

这道题其实主要就是理解题意。

本题其实就是尽量让石头分成重量相同的两堆（尽可能趋近于总重量的一半），这样就能使这两堆相撞之后剩下的石头最小，就能满足题目的要求。

我们要求撞击后石头剩余的重量，就是用总的重量减去2倍小的那堆（也可能两堆一样）的重量。所以我们就需要考虑如何实现选取某些石头达到最接近总量一半（或者刚好等于一半），这样一堆石头为多少重量。

这样就化解成01背包问题了--就和昨天打卡的 416. 分割等和子集一样了。

代码如下（一维dp）：

lass Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int sum = 0;
        for (int i = 0; i < stones.size(); i++) {
            sum += stones[i];
        }
        int mid = sum / 2;           //将石头分成两堆，每堆的重量尽可能接近总和的一半（注意这是向下取整，这样就保证了dp[mid]是小的那一堆，最后返回结果就保证了一定是正数）
        /*    01背包--一维dp   */
        vector<int> dp(mid + 1, 0);     //dp[j]表示不超过重量j时能选取的石头的最大重量和，初始化dp数组为0
        for (int i = 0; i < stones.size(); i++) {              //遍历物品（石头）
            for (int j = mid; j >= stones[i]; j--) {            //逆序遍历背包容量，确保每个石头只被使用一次
                dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
            }
        }
        return sum - dp[mid] * 2;       //返回撞击后石头剩余的重量
    }
};

题目二：494. 目标和

题目链接

494. 目标和 - 力扣（LeetCode）

给你一个非负整数数组 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

题解：动态规划--01背包

这道题感觉第一遍做很难想到。

数组里的元素本身都是正的，我们形成一个表达式可以取元素本身，也可以取元素的负值。

为什么能够联想到使用01背包呢？

我们知道，表达式包括正数和负数。知道了表达式的结果target，通过求元素总和sum，我们就能求出正数的和 size = (target + sum) / 2，题目中求满足target的方案个数，就是在求正数和为size的方案个数--这就容易联想到01背包。

通过01背包我们可以得到从数组中选取元素，满足元素和为size的种类数。-- 因为数组中只有正数，我们只需要保证选取的正数和满足size即可。其余的元素自动以负数处理。这样得到的种类数就是满足目标和为 target 的种类数。

这里还要注意的就是dp[0]的初始化：dp[0] = 1。--这个可以举例探讨。

代码如下（一维dp，附详细注释）：

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = 0;
        for (int i = 0; i < nums.size(); i++) {         //对nums数组求和
            sum += nums[i];
        }
        if (abs(target) > sum)      return 0; 
        if ((target + sum) % 2 == 1)     return 0;          //正数之和size = (target + sum) / 2肯定是整数，故(target + sum)不能为奇数
        int size = (target + sum) / 2;              //背包容量：正数的和
        /*    01背包--一维dp   */
        vector<int> dp(size + 1, 0);             //dp[j]表示：填满j这么大容积的背包，有dp[j]种方法--在这里指有dp[j]种方案可以使得正数求和为j
        dp[0] = 1;          //注意：这里初始化dp[0] = 1（可通过举例代入确定）
        for (int i = 0; i < nums.size(); i++) {             //遍历数组--这里因为数组内元素都是正数（没符号改变），故可以遍历所有元素选择得到正数之和size
            for (int j = size; j >= nums[i]; j--) {
                dp[j] += dp[j - nums[i]];         //1.如果不选第i个数（nums[i]）的话，则方法数为dp[j]；2.如果选第i个数（nums[i]）的话，则方法数为dp[j - nums[i]]
            }
        }
        return dp[size];        //正数求和为size的方案数即是满足目标和为target的方案数
    }
};

题目三：474.一和零

题目链接

474. 一和零 - 力扣（LeetCode）

给你一个二进制字符串数组 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背包的做法，但是这里要考虑到两个背包--一个背包装0，一个背包装1，这也是这道题的一个需要重要理解的部分。

01背包与本题等价关系：

物品：字符串数组strs的元素（每个元素就是一个字符串）

物品容量：1的个数：one ；0的个数：zero

背包：i，j

背包容量：i个0，j个1

最大价值：最大子集大小（长度，相当于长度每+1，价值也+1）

这样是不是就清晰多了，我们只是一个背包转换成了两个背包，但是整体思路并不发生改变。

代码如下（一维dp的二维写法）：

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        vector<vector<int>> dp(m + 1, vector<int> (n + 1, 0));      //dp[i][j]：最多有i个0和j个1的strs的最大子集的大小为dp[i][j]
        for (string str : strs) {               //挨个遍历物品str--字符串数组strs的元素
            int one = 0;
            int zero = 0;
            for (char c : str) {            //得到当前元素（物品）str中0和1的个数
                if (c == '0') {
                    zero++;
                }
                else    one++;
            }
            /*     01背包--一维dp的二维写法   */
            for (int i = m; i >= zero; i--) {            //逆序遍历两个背包：i和j
                for (int j = n; j >= one; j--) {
                    dp[i][j] = max(dp[i][j], dp[i - zero][j - one] + 1);
                }
            }
        }
        return dp[m][n];            //最多有m个0和n个1的strs的最大子集的大小为dp[m][n]
    }
};