刷题计划day29 动规01背包（一）【01背包】【分割等和子集】【最后一块石头的重量 II】
⚡刷题计划day29 动规01背包（一）开始，可以点个免费的赞哦~
往期可看专栏，关注不迷路，
您的支持是我的最大动力~
目录
背包问题前言
01背包
二维数组dp[i][j]
关于是否放物品：
关于二维dp遍历顺序：
一维数组dp（滚动数组）
关于一维dp遍历顺序：
题目一：416. 分割等和子集
题目二：1049. 最后一块石头的重量 II
背包问题前言
对于面试的话，其实掌握01背包和完全背包，就够用了，最多可以再来一个多重背包。
对于这几种背包，卡尔有个图，比较清晰：
以下对比较常见的01背包做一个简要的总结。
01背包
有n件物品和一个最多能背重量为w 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。
这是标准的背包问题
二维数组dp[i][j]
i 来表示物品、j表示背包容量。
dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。
要时刻记着这个dp数组的含义，下面的一些步骤都围绕这dp数组的含义进行的。
关于是否放物品：
-
不放物品i：背包容量为j，里面不放物品i的最大价值是dp[i - 1][j]。
-
放物品i：背包空出物品i的容量后，背包容量为j - weight[i]，dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]且不放物品i的最大价值，那么dp[i - 1][j - weight[i]] + value[i] （物品i的价值），就是背包放物品i得到的最大价值
递归公式：
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);关于二维dp遍历顺序：
先遍历 物品还是先遍历背包重量呢？
其实都可以！！ 但是先遍历物品更好理解。
以下给出给出先遍历物品，然后遍历背包重量的代码：
// weight数组的大小 就是物品个数
for(int i = 1; i < weight.size(); i++) { // 遍历物品
for(int j = 0; j <= bagweight; j++) { // 遍历背包容量
if (j < weight[i]) dp[i][j] = dp[i - 1][j];
else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
}
}一维数组dp（滚动数组）
对于背包问题其实状态都是可以压缩的，前面动态规划也有习题涉及。
在使用二维数组的时候，递推公式：
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);其实可以发现如果把dp[i - 1]那一层拷贝到dp[i]上，表达式完全可以是：
dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]);与其把dp[i - 1]这一层拷贝到dp[i]上，不如只用一个一维数组了，只用dp[j]（一维数组，也可以理解是一个滚动数组）。
这就是滚动数组的由来，需要满足的条件是上一层可以重复利用，直接拷贝到当前层。
一维dp数组，其实就上上一层 dp[i-1] 这一层 拷贝的 dp[i]来。
所以在 上面递推公式的基础上，去掉i这个维度就好。
递推公式为：
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);关于一维dp遍历顺序：
代码如下：
for(int i = 0; i < weight.size(); i++) { // 遍历物品
for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
}
}这里大家发现和二维dp的写法中，遍历背包的顺序是不一样的！
二维dp遍历的时候，背包容量是从小到大，而一维dp遍历的时候，背包是从大到小。
为什么呢？
倒序遍历是为了保证物品i只被放入一次！。但如果一旦正序遍历了，那么物品0就会被重复加入多次！
举一个例子：物品0的重量weight[0] = 1，价值value[0] = 15
如果正序遍历
dp[1] = dp[1 - weight[0]] + value[0] = 15
dp[2] = dp[2 - weight[0]] + value[0] = 30
此时dp[2]就已经是30了，意味着物品0，被放入了两次，所以不能正序遍历。
为什么倒序遍历，就可以保证物品只放入一次呢？
倒序就是先算dp[2]
dp[2] = dp[2 - weight[0]] + value[0] = 15 （dp数组已经都初始化为0）
dp[1] = dp[1 - weight[0]] + value[0] = 15
所以从后往前循环，每次取得状态不会和之前取得状态重合，这样每种物品就只取一次了。
那么问题又来了，为什么二维dp数组遍历的时候不用倒序呢？
因为对于二维dp，dp[i][j]都是通过上一层即dp[i - 1][j]计算而来，本层的dp[i][j]并不会被覆盖！
（如何这里读不懂，大家就要动手试一试了，空想还是不靠谱的，实践出真知！）
题目一：416. 分割等和子集
416.分割等和子集
(https://leetcode.cn/problems/partition-equal-subset-sum/description/)
题目要求判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。
其实只需要找到集合里能够出现 sum / 2 的子集总和，就算是可以分割成两个相同元素和子集了。
转化为背包问题：本题的本质是，能否把容量为 sum / 2的背包装满。
背包的商品是子集元素数字，那对应的 重量 和 价值 是多少呢？
此题一个数字只有一个维度，所以 重量 等于 价值，即都是等于数字的和。
以上分析完，我们就可以直接用01背包 来解决这个问题了。
还是我们之前的动规五部曲，分析如下：
1.确定dp数组以及下标的含义
01背包中，dp[j] 表示： 容量（所能装的重量）为j的背包，所背的物品价值最大可以为dp[j]。
如果背包所载重量为target， dp[target]就是装满 背包之后的总价值，因为 本题中每一个元素的数值既是重量，也是价值，所以，当 dp[target] == target 的时候，背包就装满了。
2.确定递推公式
01背包的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
本题，相当于背包里放入数值，那么物品i的重量是nums[i]，其价值也是nums[i]。
所以递推公式：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
3.dp数组如何初始化
从dp[j]的定义来看，首先dp[0]一定是0。
如果题目给的价值都是正整数那么非0下标都初始化为0就可以了，如果题目给的价值有负数，那么非0下标就要初始化为负无穷。
本题题目中 只包含正整数的非空数组，所以非0下标的元素初始化为0就可以了。
4.确定遍历顺序
前面已经说明：如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！
// 开始 01背包
for(int i = 0; i < nums.size(); i++) {
for(int j = target; j >= nums[i]; j--) { // 每一个元素一定是不可重复放入，所以从大到小遍历
dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
}
}5.举例推导dp数组
最后完整代码如下：
class Solution {
public boolean canPartition(int[] nums) {
if(nums == null || nums.length == 0) return false;
int n = nums.length;
int sum = 0;
for(int num : nums) {
sum += num;
}
//总和为奇数，不能平分
if(sum % 2 != 0) return false;
int target = sum / 2;
int[] dp = new int[target + 1];
for(int i = 0; i < n; i++) {
for(int j = target; j >= nums[i]; j--) {
//物品 i 的重量是 nums[i]，其价值也是 nums[i]
dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);
}
//剪枝，每次循环立即检查dp[target] == target
if(dp[target] == target)
return true;
}
return dp[target] == target;
}
}题目二：1049. 最后一块石头的重量 II
1049. 最后一块石头的重量 II
(https://leetcode.cn/problems/last-stone-weight-ii/description/)
本题其实是尽量让石头分成重量相同的两堆（尽可能相同），相撞之后剩下的石头就是最小的。
一堆的石头重量是sum，那么我们就尽可能拼成 重量为 sum / 2 的石头堆。 这样剩下的石头堆也是 尽可能接近 sum/2 的重量。 那么此时问题就是有一堆石头，每个石头都有自己的重量，是否可以 装满 最大重量为 sum / 2的背包。
其实想明白了思路就和上一题比较相似。
本题这样就化解成01背包问题了。
416.分割等和子集 是求背包是否正好装满，而本题是求背包最多能装多少。
物品就是石头，物品的重量为stones[i]，物品的价值也为stones[i]。
注意一下区别的地方：
最后dp[target]里是容量为target的背包所能背的最大重量。
那么分成两堆石头，一堆石头的总重量是dp[target]，另一堆就是sum - dp[target]。
在计算target的时候，target = sum / 2 因为是向下取整，所以sum - dp[target] 一定是大于等于dp[target]的。
那么相撞之后剩下的最小石头重量就是 (sum - dp[target]) - dp[target]。
完整代码如下：
class Solution {
public int lastStoneWeightII(int[] stones) {
int sum = 0;
for (int i : stones) {
sum += i;
}
int target = sum >> 1;
//初始化dp数组
int[] dp = new int[target + 1];
for (int i = 0; i < stones.length; i++) {
//采用倒序
for (int j = target; j >= stones[i]; j--) {
//两种情况，要么放，要么不放
dp[j] = Math.max(dp[j], dp[j - stones[i]] + stones[i]);
}
}
return sum - 2 * dp[target];
}
}点个免费的赞吧~