leetcode 1049.最后一块石头的重量II
题目链接：1049. 最后一块石头的重量 II - 力扣（LeetCode）
视频链接：动态规划之背包问题，这个背包最多能装多少？LeetCode：1049.最后一块石头的重量II_哔哩哔哩_bilibili
题目概述
有一堆石头，每块石头的重量都是正整数。
每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：
如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。
示例1：
输入：[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]，这就是最优值。
思路
本题和昨天的416题很像，就是让石头尽量分成重量相等的两堆，然后去碰撞，这样就又能转化成01背包问题了。
依旧是动规五部曲
1.确定dp数组以及下标含义
dp[j]表示容量（其实就是重量）为j的背包，最多可以背最大重量为dp[j]。
2.确定递推公式
dp[j] = max(dp[j], dp[j - stones[i]] + stones[i])。
3.dp数组初始化
把dp[j]初始化成零就可以了。
4.确定遍历顺序
第一层for循环遍历物品，第二层for循环遍历背包（倒叙）。
5.打印dp数组
代码实现
class Solution {
public:
int lastStoneWeightII(vector<int>& stones) {
vector<int> dp(15001,0);
int sum = 0;
for(int i = 0;i < stones.size();i++) {
sum += stones[i] ;
}
int target = sum /2;
for(int i = 0;i < stones.size();i++) {
for(int j = target;j >= stones[i];j--) {
dp[j] = max(dp[j],dp[j - stones[i]] + stones[i]);
}
}
return sum - dp[target] - dp[target];
}
};leetcode 494.目标和
题目链接：494. 目标和 - 力扣（LeetCode）
视频链接：动态规划之背包问题，装满背包有多少种方法？| LeetCode：494.目标和_哔哩哔哩_bilibili
题目概述
给你一个非负整数数组 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
思路
本题也可以转化成01背包问题，把集合分成两份 一个正集合（所有数字前都是‘+’）和 一个负集合（所有数字前都是‘-’），加法集合的总和就设为x，那么减法集合的总和就是sum-x，我们的target=x-（sum-x），所以x=（target+sum）/2。
例如：输入：nums = [1,1,1,1,1], target = 2，（（target+sum）% 2 == 1）那么就没有方案了。
如果target＞sum，也没有方案。
说白了就是本题有几种方式装满背包。
依旧是动规五部曲
1.确定dp数组以及下标含义
dp[j] 表示：填满j（包括j）这么大容积的包，有dp[j]种方法。
2.确定递推公式
dp[j] += dp[j - nums[i]]。
3.dp数组初始化
dp[0]=1。
4.确定遍历顺序
第一层for循环遍历nums，第二层for循环遍历target（倒叙）。
5.打印dp数组（以示例1为例）
代码实现
lass Solution {
public:
int findTargetSumWays(vector<int>& nums, int target) {
int sum = 0;
for(int i = 0;i < nums.size();i++) {
sum += nums[i];
}
if(abs(target) > sum || (target + sum) % 2 == 1) return 0;
int bagSize = (target + sum) / 2;
vector<int> dp(bagSize + 1,0);
dp[0] = 1;
for(int i =0;i <nums.size();i++) {
for(int j = bagSize;j >= nums[i];j--) {
dp[j] += dp[j - nums[i]];
}
}
return dp[bagSize];
}
};leetcode 474.一和零
题目链接：474. 一和零 - 力扣（LeetCode）
视频链接：动态规划之背包问题，装满这个背包最多用多少个物品？| LeetCode：474.一和零_哔哩哔哩_bilibili
题目概述
给你一个二进制字符串数组 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 。
思路
本题还是01背包
依旧是动规五部曲
1.确定dp数组以及下标含义
dp[i][j]：最多有i个0和j个1的strs的最大子集的大小为dp[i][j]。
2.确定递推公式
递推公式：dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1)
每道题的递推公式其实都是根据01背包的理论基础推理的来的（01背包的递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i])）
3.dp数组初始化
还是初始为0，以防把后面的值给覆盖了。
4.确定遍历顺序
第一层for循环遍历物品（也就是字符串），第二层for循环遍历背包（从后向前遍历）。
5.打印dp数组
代码实现
class Solution {
public:
int findMaxForm(vector<string>& strs, int m, int n) {
vector<vector<int>> dp(m + 1,vector<int> (n + 1,0));
for(string str : strs) {
int oneNum = 0,zeroNum = 0;
for(char c : str) {
if(c == '0') zeroNum++;
else oneNum++;
}
for(int i = m;i >= zeroNum;i--) {
for(int j = n;j >= oneNum;j--) {
dp[i][j] = max(dp[i][j],dp[i - zeroNum][j - oneNum] + 1);
}
}
}
return dp[m][n];
}
};
