一定要理解每题为什么用01背包解题，这样才能用01背包的思维解题。（这也是困惑了我很久的点）
1049 最后一块石头的重量II
为什么使用01背包
我们发现在满足题意时，可以看成两个总和尽可能相等的集合，那样达成目的：两个集合间石头粉碎后才能使最后石头重量最小。
从这两个集合中寻找规律会发现，两个集合的总和相加当然是等于数组的总和Sum1 + Sum2 = Sum
反过来把Sum除以2就是要求的Sum1 （因为要求两个总和尽可能相等），我们把这个值命名为target
因此问题就转化为：在集合中找到一组数字他们能装满（等于）target
这就是典型的01背包了
（关于01背包问题的基础详见01背包问题）
✍手写分析
01背包的动规五部曲
接下来进行动规五步曲：
- 确定dp数组以及下标的含义
dp[j]表示容量（这里说容量更形象，其实就是重量）为j的背包，最多可以背最大重量为dp[j]。
回忆一下纯01背包问题中，dp[j]的含义，容量为j的背包，最多可以装的价值为 dp[j]。
相对于 01背包，本题中，石头的重量是 stones[i]，石头的价值也是 stones[i] ，可以 “最多可以装的价值为 dp[j]” == “最多可以背的重量为dp[j]”
- 确定递推公式
纯01背包的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
因此本题则是：dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
- dp数组如何初始化
大小：背包最大容量也是我们目标容量就是我们上面所说的target。
值：因为重量都不会是负数，所以dp[j]都初始化为0就可以了，这样在递归公式dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);中dp[j]才不会因为初始值过大所覆盖。
代码为：
int[] dp = new int[target + 1];
- 确定遍历顺序
一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！
同样详见01背包问题
代码如下：
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]);
}
}
- 举例推导dp数组
举例，输入：[2,4,1,1]，此时target = (2 + 4 + 1 + 1)/2 = 4 ，dp数组状态图如下：
最后dp[target]里是容量为target的背包所能背的最大重量。
那么分成两堆石头，一堆石头的总重量是dp[target]，另一堆就是sum - dp[target]。
在计算target的时候，target = sum / 2 因为是向下取整，所以sum - dp[target] 一定是大于等于dp[target]的。
那么相撞之后剩下的最小石头重量就是 (sum - dp[target]) - dp[target]。
以上分析完毕，代码如下：
public int lastStoneWeightII(int[] stones) {
int sum = 0;
for (int stone : stones) {
sum += stone;
}
int target = sum / 2;
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]);
}
}
// 求相减后最小的石头大小 - 另一半（大一些,由于sum / 2向下取整）减去dp[target]
return sum - dp[target] - dp[target];
}
- 时间复杂度：O(m × n) , m是石头总重量（准确的说是总重量的一半），n为石头块数
- 空间复杂度：O(m）
494 目标和
为什么要用01背包
同样，满足题意时，可以分成＋的集合（命名为left）和-的集合（right），而这两个集合间元素相减就会等于target，于是就有：left - right = targetleft + right = Sum
=> left = (target + Sum) / 2
target与Sum都为已知，left可以算出。只要确定了left，根据sum也可以知道right的值了。
（_这里注意：如果 __(target + Sum)_是奇数，那么得出left会是小数，而元素都是正整数所以不能满足条件）
因此问题就转化为：以left（这里更名为bagSize）为容量，装满（之和等于）最多有几种方法
这就是典型的背包问题了
✍手写分析
01背包的动规五部曲
这次和之前遇到的背包问题不一样了，之前都是求容量为j的背包，最多能装多少。
本题则是装满有几种方法。其实这就是一个组合问题了。(下面递推时候用到)
- 确定dp数组以及下标的含义
dp[j] 表示：填满j（包括j）这么大容积的包，有dp[j]种方法
- 确定递推公式
有哪些来源可以推出dp[j]呢？
只要搞到nums[i]，凑成dp[j]就有dp[j - nums[i]] 种方法。
例如：dp[j]，j 为5，
- 已经有一个1（nums[i]） 的话，有 dp[4]种方法 凑成 容量为5的背包。
- 已经有一个2（nums[i]） 的话，有 dp[3]种方法 凑成 容量为5的背包。
- 已经有一个3（nums[i]） 的话，有 dp[2]中方法 凑成 容量为5的背包
- 已经有一个4（nums[i]） 的话，有 dp[1]中方法 凑成 容量为5的背包
- 已经有一个5 （nums[i]）的话，有 dp[0]中方法 凑成 容量为5的背包
那么凑整dp[5]有多少方法呢，也就是把 所有的 dp[j - nums[i]] 累加起来。
所以求组合类问题的公式，都是类似这种：通过每一层相加，在最后一层想加完每一件物品最大的情况
dp[j] += dp[j - nums[i]]
这个公式在后面在讲解背包解决排列组合问题的时候还会用到！
- dp数组如何初始化
从递推公式来看，在初始化的时候dp[0] 一定要初始化为1，因为dp[0]是在公式中一切递推结果的起源，如果dp[0]是0的话，递推结果将都是0。
从题目逻辑来看，如果数组[0] ，target = 0，那么 bagSize = (target + sum) / 2 = 0。 dp[0]也应该是1， 也就是说给数组里的元素 0 前面无论放加法还是减法，都是 1 种方法。
所以本题我们应该初始化 dp[0] 为 1。
dp[j]其他下标对应的数值也应该初始化为0，从递推公式也可以看出，dp[j]要保证是0的初始值，才能正确的由dp[j - nums[i]]推导出来。
- 确定遍历顺序
01背包问题一维dp的遍历，nums放在外循环，target在内循环，且内循环倒序。
- 举例推导dp数组
输入：nums: [1, 1, 1, 1, 1], S: 3
bagSize = (S + sum) / 2 = (3 + 5) / 2 = 4
dp数组状态变化如下：
代码如下：
public int findTargetSumWays(int[] nums, int target) {
int sum = 0;
for (int num : nums) {
sum += num;
}
// 判断nums是否能满足target
if (target < 0 && sum < -target) return 0;
// (sum + target)不能是奇数
if ((sum + target) % 2 != 0) return 0;
int bagSize = (sum + target) / 2;
// 负数变正数 （正负逻辑一致）
if (bagSize < 0) bagSize = -bagSize;
int[] dp = new int[bagSize + 1];
// 初始化
dp[0] = 1;
for (int i = 0; i < nums.length; i++) {
for (int j = bagSize; j >= nums[i]; j--) {
dp[j] += dp[j - nums[i]];
}
}
return dp[bagSize];
}
- 时间复杂度：O(n × m)，n为正数个数，m为背包容量
- 空间复杂度：O(m)，m为背包容量
总结
此时 不禁想起之前刷过的回溯算法：39. 组合总和是不是也可以用dp来做？
是的，如果仅仅是求个数的话，就可以用dp，但回溯算法：39. 组合总和要求的是把所有组合列出来，还是要使用回溯法爆搜的。
本题还是有点难度，也可以记住，在求装满背包有几种方法的组合情况下，递推公式一般为：
dp[j] += dp[j - nums[i]];
（后面完全背包的时候，还会用到这个递推公式~）
474 一和零
为什么使用01背包（✍手写分析）
见全过程✍手写分析图：
01背包？多重背包？
本题可能会认为是多重背包，一些题解也是这么写的。
其实本题并不是多重背包，再来看一下这个图，捋清几种背包的关系
多重背包是每个物品，数量不同从而可以用多次，被称为多重背包。
本题中strs 数组里的元素就是物品，每个物品都是一个！
而m 和 n相当于是一个背包，相当于两个维度的背包。
理解成多重背包主要是把m和n混淆为物品了，感觉这是不同数量的物品，所以以为是多重背包。
但本题其实是01背包问题！
只不过这个背包有两个维度，一个是m 一个是n，而不同长度的字符串就是不同大小的待装物品。
01背包动规五部曲
- 确定dp数组（dp table）以及下标的含义
dp[i][j]：最多有i个0和j个1的strs的最大子集的长度
- 确定递推公式
dp[i][j] 可以由前一个strs里的字符串推导出来，strs里的字符串有x个0，y个1。
dp[i][j] 就可以是 dp[i - x][j - y] + 1。
然后我们在遍历的过程中，取dp[i][j]的最大值。
所以递推公式：dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
此时大家可以回想一下01背包的递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
对比一下就会发现，字符串的x和y相当于物品的重量（weight[i]），字符串本身的个数相当于物品的价值（value[i]）。
因此再次说明这就是一个典型的01背包！ 只不过物品的重量有了两个维度而已。
- dp数组如何初始化
因为物品价值不会是负数，初始为0，保证递推的时候dp[i][j]不会被初始值覆盖。
- 确定遍历顺序
外层for循环遍历物品，内层for循环遍历背包容量且从后向前遍历！
那么本题也是，物品就是strs里的字符串，背包容量就是题目描述中的m和n。
代码如下：
for (String str : strs) {
// 先统计x y
int x = 0,y = 0;
for (char c : str.toCharArray()) {
if (c == '0') x++;
else y++;
}
for (int i = m; i >= x; i--){// 0的个数
for (int j = n; j >= y; j--){// 1的个数
dp[i][j] = Math.max(dp[i][j],dp[i - x][j - y] + 1);
}
}
}
- 举例推导dp数组
以输入：["10","0001","111001","1","0"]，m = 3，n = 3为例
最后dp数组的状态如下所示：
以上动规五部曲分析完毕，代码如下：
public int findMaxForm(String[] strs, int m, int n) {
int[][] dp = new int[m + 1][n + 1];
for (String str : strs) {
// 先统计x y
int x = 0,y = 0;
for (char c : str.toCharArray()) {
if (c == '0') x++;
else y++;
}
for (int i = m; i >= x; i--){
for (int j = n; j >= y; j--){
dp[i][j] = Math.max(dp[i][j],dp[i - x][j - y] + 1);
}
}
}
return dp[m][n];
}
- 时间复杂度: O(kmn)，k 为strs的长度
- 空间复杂度: O(mn)
总结
我们刷了不少01背包不同的应用题目:
- 纯 0 - 1 背包是求 给定背包容量 装满背包 的最大价值是多少。
- 416. 分割等和子集求 给定背包容量，能不能装满这个背包。
- 1049. 最后一块石头的重量 II 求 给定背包容量，尽可能装，最多能装多少
- 494. 目标和 是求 给定背包容量，装满背包有多少种方法。
- 474 一和零 是求 给定背包容量，装满背包最多有多少个物品。
都是 0-1背包不同维度上的应用，可以细心体会~
学习资料:
