动态规划篇--代码随想录算法训练营第三十四天| 416. 分割等和子集，1049.最后一块石头的重量II，494.目标和，474.一和零

最新推荐文章于 2024-08-19 11:12:00 发布

热爱编程的OP

最新推荐文章于 2024-08-19 11:12:00 发布

阅读量600

点赞数 18

分类专栏： leetcode 文章标签：算法动态规划 leetcode c++

本文链接：https://blog.csdn.net/m0_67804957/article/details/141310928

版权

leetcode 专栏收录该内容

31 篇文章 0 订阅

订阅专栏

416. 分割等和子集

题目链接：. - 力扣（LeetCode）

讲解视频：

动态规划之背包问题，这个包能装满吗？| LeetCode：416.分割等和子集

题目描述：

给你一个 只包含正整数 的非空数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

示例 1：

输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。

解题思路：

算法思路：
先将问题转化成我们「熟悉」的题型。
如果数组能够被分成两个相同元素之和相同的子集，那么原数组必须有下面几个性质：

所有元素之和应该是一个偶数；
数组中最大的元素应该小于所有元素总和的一半；
挑选一些数，这些数的总和应该等于数组总和的一半。

根据前两个性质，我们可以提前判断数组能够被划分。根据最后一个性质，我们发现问题就转化成了「01 背包」的模型：

数组中的元素只能选择一次；
每个元素面临被选择或者不被选择的处境；
选出来的元素总和要等于所有元素总和的一半。

其中，数组内的元素就是物品，总和就是背包。那么我们就可以用背包模型的分析方式，来处理这道题。

1. 状态表示：
dp[i][j] 表示在前 i 个元素中选择，所有的选法中，能否凑成总和为 j 这个数。

2. 状态转移方程：
根据「最后一个位置」的元素，结合题目的要求，分情况讨论：

不选择 nums[i] ：那么我们是否能够凑成总和为 j ，就要看在前 i - 1 个元素中选，能否凑成总和为 j 。根据状态表示，此时 dp[i][j] = dp[i - 1][j] ；
选择 nums[i] ：这种情况下是有前提条件的，此时的 nums[i] 应该是小于等于 j 。因为如果这个元素都比要凑成的总和大，选择它就没有意义呀。那么我们是否能够凑成总和为 j ，就要看在前 i - 1 个元素中选，能否凑成总和为 j - nums[i] 。根据状态表示，此时 dp[i][j] = dp[i - 1][j - nums[i]] 。

综上所述，两种情况下只要有一种能够凑成总和为 j ，那么这个状态就是 true 。因此，状态转移方程为：
dp[i][j] = dp[i - 1][j]
if(nums[i - 1] <= j) dp[i][j] = dp[i][j] || dp[i - 1][j -nums[i]]

3. 初始化：
由于需要用到上一行的数据，因此我们可以先把第一行初始化。第一行表示不选择任何元素，要凑成目标和 j 。只有当目标和为 0 的时候才能做到，因此第一行仅需初始化第一个元素 dp[0][0] = true

4. 填表顺序：
根据「状态转移方程」，我们需要「从上往下」填写每一行，每一行的顺序是「无所谓的」。

5. 返回值：
根据「状态表示」，返回 dp[n][aim] 的值。其中 n 表示数组的大小， aim 表示要凑的目标和。

代码：

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

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

题目链接：. - 力扣（LeetCode）

讲解视频：

这个背包最多能装多少？LeetCode：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]，这就是最优值。

解题思路：

算法思路：
先将问题「转化」成我们熟悉的题型。

任意两块石头在一起粉碎，重量相同的部分会被丢掉，重量有差异的部分会被留下来。那就相当于在原始的数据的前面，加上「加号」或者「减号」，是最终的结果最小即可。也就是说把原始的石头分成两部分，两部分的和越接近越好。
又因为当所有元素的和固定时，分成的两部分越接近数组「总和的一半」，两者的差越小。因此问题就变成了：在数组中选择一些数，让这些数的和尽量接近 sum / 2 ，如果把数看成物品，每个数的值看成体积和价值，问题就变成了「01 背包问题」。

1. 状态表示：
dp[i][j] 表示在前 i 个元素中选择，总和不超过 j，此时所有元素的「最大和」。

2. 状态转移方程：
根据「最后一个位置」的元素，结合题目的要求，分情况讨论：

不选 stones[i] ：那么我们是否能够凑成总和为 j ，就要看在前 i - 1 个元素中选，能否凑成总和为 j 。根据状态表示，此时 dp[i][j] = dp[i - 1][j] ；
选择 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. 返回值：

根据「状态表示」，先找到最接近 sum / 2 的最大和 dp[n][sum / 2] ；
因为我们要的是两堆石子的差，因此返回 sum - 2 * dp[n][sum / 2] 。

代码：

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int n = stones.size(), sum = 0;
        for(auto x : stones) sum += x;
        int aim = sum / 2;
        vector<vector<int>> dp(n+1,vector<int>(aim+1));
        for(int i = 1; i <= n; i++)
        {
            for(int j = 0; j <= aim; j++)
            {
                dp[i][j] = dp[i-1][j];
                if(j >= stones[i-1])
                    dp[i][j] = max(dp[i][j], dp[i-1][j-stones[i-1]]+stones[i-1]);
            }
        }
        int remain = sum - dp[n][aim];
        return abs(dp[n][aim] - remain);
    }
};

494.目标和

题目链接：. - 力扣（LeetCode）

讲解视频：

装满背包有多少种方法？| LeetCode：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. 状态转移方程：
老规矩，根据「最后一个位置」的元素，结合题目的要求，我们有「选择」最后一个元素或者「不选择」最后一个元素两种策略：

不选 nums[i] ：那么我们凑成总和 j 的总方案，就要看在前 i - 1 个元素中选，凑成总和为 j 的方案数。根据状态表示，此时 dp[i][j] = dp[i - 1][j] ；
选择 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 - 1][j - nums[i- 1]]

3. 初始化：
由于需要用到「上一行」的数据，因此我们可以先把第一行初始化。第一行表示不选择任何元素，要凑成目标和 j 。只有当目标和为 0 的时候才能做到，因此第一行仅需初始化第一个元素 dp[0][0] = 1

4. 填表顺序：
根据「状态转移方程」，我们需要「从上往下」填写每一行，每一行的顺序是「无所谓的」。

5. 返回值：
根据「状态表示」，返回 dp[n][aim] 的值。其中 n 表示数组的大小， aim 表示要凑的目标和。

代码：

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

474.一和零

题目链接：. - 力扣（LeetCode）

讲解视频：

装满这个背包最多用多少个物品？| LeetCode：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 。

解题思路：

算法思路：
先将问题转化成我们熟悉的题型。

在一些物品中「挑选」一些出来，然后在满足某个「限定条件」下，解决一些问题，大概率是背包模型；
由于每一个物品都只有 1 个，因此是一个「01 背包问题」。

但是，我们发现这一道题里面有「两个限制条件」。因此是一个「二维费用的 01 背包问题」。那么我们定义状态表示的时候，来一个三维 dp 表，把第二个限制条件加上即可。

1. 状态表示：
dp[i][j][k] 表示：从前 i 个字符串中挑选，字符 0 的个数不超过 j ，字符 1 的个数不超过 k ，所有的选法中，最大的长度。

2. 状态转移方程：
线性 dp 状态转移方程分析方式，一般都是「根据最后一步」的状况，来分情况讨论。为了方便叙述，我们记第 i 个字符中，字符 0 的个数为 zero ，字符 1 的个数为 one ：

不选第 i 个字符串：相当于就是去前 i - 1 个字符串中挑选，并且字符 0 的个数不超过 j ，字符 1 的个数不超过 k 。此时的最大长度为 dp[i][j][k] = dp[i - 1][j][k] ；
选择第 i 个字符串：那么接下来我仅需在前 i - 1 个字符串里面，挑选出来字符 0 的个数不超过 j -zero ，字符 1 的个数不超过 k - one 的最长长度，然后在这个长度后面加上字符串 i 即可。。此时 dp[i][j][k] = dp[i - 1][j - zero][k-one] + 1 。但是这种状态不一定存在，因此需要特判一下。

综上，状态转移方程为： dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j - zero][k-one]+1)
[k - b] + 1) 。

3. 初始化：
当没有字符串的时候，没有长度，因此初始化为 0 即可。

4. 填表顺序：
保证第一维的循环「从小到大」即可。

5. 返回值：
根据「状态表示」，我们返回 dp[len][m][n] 。其中 len 表示字符串数组的长度。

代码：

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        int len = strs.size();
        vector<vector<vector<int>>> dp(len+1,vector<vector<int>>(m+1,vector<int>(n+1)));
        for(int i = 1; i <= len; i++)
        {
            int zero = 0, one = 0;
            for(auto x : strs[i-1])
            {
                if(x == '0') zero++;
                else one++;
            }
            for(int j = 0; j <= m; j++)
            {
                for(int k = 0; k <= n; k++)
                {
                    dp[i][j][k] = dp[i-1][j][k];
                    if(j >= zero && k >= one)
                        dp[i][j][k] = max(dp[i][j][k],dp[i-1][j-zero][k-one]+1);
                }
            }
        }
        return dp[len][m][n];
    }
};

热爱编程的OP

关注

18
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
动态规划篇--代码随想录算法训练营第三十四天| 416. 分割等和子集，1049.最后一块石头的重量II，494.目标和，474.一和零

416. 分割等和子集，1049.最后一块石头的重量II，494.目标和，474.一和零
复制链接

扫一扫

专栏目录