0-1背包
有N件物品和⼀个最多能被重量为W 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能⽤⼀次，求解将哪些物品装⼊背包⾥物品价值总和最⼤。
每⼀件物品其实只有两个状态，取或者不取，所以可以使⽤回溯法搜索出所有的情况，那么时间复杂度就是O(2^n)，这⾥的n表示物品数量。
所以暴⼒的解法是指数级别的时间复杂度。进⽽才需要动态规划的解法来进⾏优化！
示例
背包最⼤重量为4。
物品为
问背包能背的物品最⼤价值是多少？
解法一:⼆维dp数组01背包
使用动态规划五部曲分析⼀波。
1. 确定dp数组（dp table）以及下标的含义
对于背包问题，有⼀种写法， 是使⽤⼆维数组，即dp[i][j] 表示从下标为[0-i]的物品⾥任意取，放进容量为j的背包，价值总和最⼤是多少,如下图
image.png
2. 确定递推公式
再回顾⼀下dp[i][j]的含义：从下标为[0-i]的物品⾥任意取，放进容量为j的背包，价值总和最⼤是多少。
那么可以有两个⽅向推出来dp[i][j]，
- 不选择第i件物品,背包容量为j，⾥⾯不放物品i的最⼤价值，此时dp[i][j]就是dp[i - 1][j]
- 选择第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数组如何初始化
关于初始化，⼀定要和dp数组的定义吻合，否则到递推公式的时候就会越来越乱。
⾸先从dp[i][j]的定义触发，如果背包容量j为0的话，即dp[i][0]，⽆论是选取哪些物品，背包价值总和⼀定为0。如图：
image.png
在看其他情况。
- 状态转移⽅程 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 可以看出i 是由 i-1 推导出来，那么i为0的时候就⼀定要初始化。
dp[0][j]，即：i为0，存放编号0的物品的时候，各个容量的背包所能存放的最⼤价值。
代码如下：
// 倒叙遍历
for (int j = bagWeight; j >= weight[0]; j--) {
dp[0][j] = dp[0][j - weight[0]] + value[0]; // 初始化i为0时候的情况
}
备注:这个初始化为什么是倒叙的遍历的？正序遍历就不⾏么？
正序遍历还真就不⾏，dp[0][j]表示容量为j的背包存放物品0时候的最⼤价值，物品0的价值就是15，因为题⽬中说了每个物品只有⼀个！所以dp[0][j]如果不是初始值的话，就应该都是物品0的价值，也就是15。
但如果⼀旦正序遍历了，那么物品0就会被重复加⼊多次！ 例如代码如下：
// 正序遍历
for (int j = weight[0]; j <= bagWeight; j++) {
dp[0][j] = dp[0][j - weight[0]] + value[0];
}
例如dp[0][1] 是15，到了dp[0][2] = dp[0][2 - 1] + 15; 也就是dp[0][2] = 30 了，那么就是物品0被重复放⼊了。
所以⼀定要倒叙遍历，保证物品0只被放⼊⼀次！这⼀点对01背包很重要，后⾯在讲解滚动数组的时
候，还会⽤到倒叙遍历来保证物品使⽤⼀次！
此时dp数组初始化情况如图所示：
dp[0][j] 和 dp[i][0] 都已经初始化了，那么其他下标应该初始化多少呢？
dp[i][j]在推导的时候⼀定是取价值最⼤的数，如果题⽬给的价值都是正整数那么⾮0下标都初始化为0就可以了，因为0就是最⼩的了，不会影响取最⼤价值的结果。
如果题⽬给的价值有负数，那么⾮0下标就要初始化为负⽆穷了。例如：⼀个物品的价值是-2，但对应的位置依然初始化为0，那么取最⼤值的时候，就会取0⽽不是-2了，所以要初始化为负⽆穷。
这样才能让dp数组在递归公式的过程中取最⼤的价值，⽽不是被初始值覆盖了。
最后初始化代码如下：
// 初始化 dp
vector> dp(weight.size() + 1, vector(bagWeight + 1, 0));
for (int j = bagWeight; j >= weight[0]; j--) {
dp[0][j] = dp[0][j - weight[0]] + value[0];
}
-
确定遍历顺序
在如下图中，可以看出，有两个遍历的维度：物品与背包重量
image.png
那么问题来了，先遍历 物品还是先遍历背包重量呢？
一:我先给出先遍历物品，然后遍历背包重量的代码。
// 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]; // 这个是为了展现dp数组⾥元素的变化
else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
}
}
二:先遍历背包，再遍历物品
// weight数组的⼤⼩ 就是物品个数
for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
for(int i = 1; i < weight.size(); i++) { // 遍历物品
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[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 递归公式中可以看出dp[i][j]是靠dp[i-1][j]和dp[i - 1][j - weight[i]]推导出来的。
dp[i-1][j]和dp[i - 1][j - weight[i]] 都在dp[i][j]的左上⻆⽅向（包括正左和正上两个⽅向），那么不论是先遍历物品，再遍历背包,还是先遍历背包,再遍历物品
虽然两个for循环遍历的次序不同，但是dp[i][j]所需要的数据就是左上⻆，根本不影响
dp[i][j]公式的推导！
但先遍历物品再遍历背包这个顺序更好理解。
-
推导dp数组
来看⼀下对应的dp数组的数值，如图：
image.png
最终结果就是dp[2][4]。
做动态规划的题⽬，最好的过程就是⾃⼰在纸上举⼀个例⼦把对应的dp数组的数值推导⼀下，然后在动⼿写代码！
如果推导明⽩了，代码写出来就算有问题，只要把dp数组打印出来，对⽐⼀下和⾃⼰推导的有什么差异，很快就可以发现问题了。
解法二:⼀维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[i][j]⾥的i和j表达的是什么了，i是物品，j是背包容量。
dp[i][j] 表示从下标为[0-i]的物品⾥任意取，放进容量为j的背包，价值总和最⼤是多少。
- 确定dp数组的定义
在⼀维dp数组中，dp[j]表示：容量为j的背包，所背的物品价值可以最⼤为dp[j]。
- ⼀维dp数组的递推公式
dp[j]为 容量为j的背包所背的最⼤价值，那么如何推导dp[j]呢？
dp[j]可以通过dp[j - weight[j]]推导出来，dp[j - weight[i]]表示容量为j - weight[i]的背包所背的最⼤价值。
dp[j - weight[i]] + value[i] 表示 容量为 j - 物品i重量 的背包 加上 物品i的价值。（也就是容量为j的背包，放⼊物品i了之后的价值即：dp[j]）
此时dp[j]有两个选择，⼀个是取⾃⼰dp[j]，⼀个是取dp[j - weight[i]] + value[i]，指定是取最⼤的，毕竟是求最⼤价值，
所以递归公式为：
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
可以看出相对于⼆维dp数组的写法，就是把dp[i][j]中i的维度去掉了。
- ⼀维dp数组如何初始化
关于初始化，⼀定要和dp数组的定义吻合，否则到递推公式的时候就会越来越乱。
dp[j]表示：容量为j的背包，所背的物品价值可以最⼤为dp[j]，那么dp[0]就应该是0，因为背包容量为0,所背的物品的最⼤价值就是0。
那么dp数组除了下标0的位置，初始为0，其他下标应该初始化多少呢？
看⼀下递归公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
dp数组在推导的时候⼀定是取价值最⼤的数，如果题⽬给的价值都是正整数那么⾮0下标都初始化为0就可以了，如果题⽬给的价值有负数，那么⾮0下标就要初始化为负⽆穷。
- ⼀维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遍历的时候，背包是从⼤到⼩。
为什么呢？
倒叙遍历是为了保证物品i只被放⼊⼀次！
举⼀个例⼦：物品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]并不会被覆盖！
代码中是先遍历物品嵌套遍历背包容量，那可不可以先遍历背包容量嵌套遍历物品呢？
不可以！
因为⼀维dp的写法，背包容量⼀定是要倒序遍历，如果遍历背包容量放在上⼀层，那么每个dp[j]就只会放⼊⼀个物品(因为会被覆盖)，即：背包⾥只放⼊了⼀个物品。
所以⼀维dp数组的背包在遍历顺序上和⼆维其实是有很⼤差异的！
-
推导dp数组
⼀维dp，分别⽤物品0，物品1，物品2 来遍历背包，最终得到结果如下：
image.png
完全背包
⼀个商品如果可以重复多次放⼊是完全背包，⽽只能放⼊⼀次是01背包
有N件物品和⼀个最多能背重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品都有⽆限个（也就是可以放⼊背包多次），求解将哪些物品装⼊背包⾥物品价值总和最⼤。
区别
01背包和完全背包唯⼀不同就是体现在遍历顺序上
01背包的核⼼代码
01背包内嵌的循环是从⼤到⼩遍历，为了保证每个物品仅被添加⼀次。
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]);
}
}
01背包dp状态图如下:
完全背包核心代码
完全背包的物品是可以添加多次的，所以要从⼩到⼤去遍历
// 先遍历物品，再遍历背包
for(int i = 0; i < weight.size(); i++) { // 遍历物品
for(int j = weight[i]; j < bagWeight ; j++) { // 遍历背包容量
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
}
}
完全背包dp状态图如下：
出题类型
常见的背包问题有
1、组合问题。2、True、False问题。3、最大最小问题。
1、组合问题： 377. 组合总和 Ⅳ 494. 目标和 518. 零钱兑换 II
2、True、False问题： 139. 单词拆分 416. 分割等和子集
3、最大最小问题： 474. 一和零 322. 零钱兑换
组合问题公式
dp[i] += dp[i-num]
True、False问题公式
dp[i] = dp[i] or dp[i-num]
最大最小问题公式
dp[i] = min(dp[i], dp[i-num]+1)或者dp[i] = max(dp[i], dp[i-num]+1)
组合问题例子
以目标和为例
题⽬链接：https://leetcode-cn.com/problems/target-sum/
给定⼀个⾮负整数数组，a1, a2, ..., an, 和⼀个⽬标数，S。现在你有两个符号 + 和 -。对于数组中的任意⼀个整数，你都可以从 + 或 -中选择⼀个符号添加在前⾯
返回可以使最终数组和为⽬标数 S 的所有添加符号的⽅法数
示例：
输⼊：nums: [1, 1, 1, 1, 1], S: 3
输出：5
解释：
-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
⼀共有5种⽅法让最终⽬标和为3。
提示：
- 数组⾮空，且⻓度不会超过 20 。
- 初始的数组的和不会超过 1000 。
- 保证返回的最终结果能被 32 位整数存下。
思路
本题要如何使表达式结果为target，
既然为target，那么就⼀定有 left组合 - right组合 = target。
left + right等于sum，⽽sum是固定的。
公式来了， left - (sum - left) = target -> left = (target + sum)/2 。
target是固定的，sum是固定的，left就可以求出来。
所以此时问题就是在集合nums中找出和为left的组合。
假设加法的总和为x，那么减法对应的总和就是sum - x。
所以我们要求的是 x - (sum - x) = S
x = (S + sum) / 2
此时问题就转化为，装满容量为x背包，有⼏种⽅法
⼤家看到(S + sum) / 2 应该担⼼计算的过程中向下取整有没有影响。
这么担⼼就对了，例如sum 是5，S是2的话其实就是⽆解的，所以：
if ((S + sum) % 2 == 1) return 0; // 此时没有⽅案
看到这种表达式，应该本能的反应，两个int相加数值可能溢出的问题，当然本题并没有溢出。
再回归到01背包问题，为什么是01背包呢？
因为每个物品（题⽬中的1）只⽤⼀次！
这次和之前遇到的背包问题不⼀样了，之前都是求容量为j的背包，最多能装多少。
本题则是装满有⼏种⽅法。其实这就是⼀个组合问题了。
动规五部曲分析如下：
- 确定dp数组以及下标的含义
dp[j] 表示：填满j（包括j）这么⼤容积的包，有dp[i]种⽅法
- 确定递推公式
有哪些来源可以推出dp[j]呢？
不考虑nums[i]的情况下，填满容量为j - nums[i]的背包，有dp[j - nums[i]]中⽅法。
那么只要搞到nums[i]的话，凑成dp[j]就有dp[j - nums[i]] 种⽅法。
举⼀个例⼦,nums[i] = 2： dp[3]，填满背包容量为3的话，有dp[3]种⽅法。
那么只需要搞到⼀个2（nums[i]），有dp[3]⽅法可以凑⻬容量为3的背包，相应的就有多少种⽅法可以凑⻬容量为5的背包。
那么需要把 这些⽅法累加起来就可以了，dp[i] += dp[j - nums[i]]
所以求组合类问题的公式，都是类似这种：
dp[j] += dp[j - nums[i]]
- dp数组如何初始化
从递归公式可以看出，在初始化的时候dp[0] ⼀定要初始化为1，因为dp[0]是在公式中⼀切递推结果的起源，如果dp[0]是0的话，递归结果将都是0。
dp[0] = 1，理论上也很好解释，装满容量为0的背包，有1种⽅法，就是装0件物品。
dp[j]其他下标对应的数值应该初始化为0，从递归公式也可以看出，dp[j]要保证是0的初始值，才能正确的由dp[j - nums[i]]推导出来。
4..确定遍历顺序
01背包问题⼀维dp的遍历，nums(物品)放在外循环，target(背包)在内循环，且内循环倒序。
- 举例推导dp数组
输⼊：nums: [1, 1, 1, 1, 1], S: 3
bagSize = (S + sum) / 2 = (3 + 5) / 2 = 4
dp数组状态变化如下：
如果仅仅是求个数的话，就可以⽤dp，如果要求的是把所有组合列出来，
还是要使⽤回溯法爆搜的
零钱兑换 II
链接：https://leetcode-cn.com/problems/coin-change-2/
给定不同⾯额的硬币和⼀个总⾦额。写出函数来计算可以凑成总⾦额的硬币组合数。假设每⼀种⾯额的硬币有⽆限个。
示例 1:
输⼊: amount = 5, coins = [1, 2, 5]
输出: 4
解释: 有四种⽅式可以凑成总⾦额:
5=5
5=2+2+1
5=2+1+1+1
5=1+1+1+1+1
示例 2:
输⼊: amount = 3, coins = [2]
输出: 0
解释: 只⽤⾯额2的硬币不能凑成总⾦额3。
示例 3:
输⼊: amount = 10, coins = [10]
输出: 1
注意，你可以假设：
0 <= amount (总⾦额) <= 5000
1 <= coin (硬币⾯额) <= 5000
硬币种类不超过 500 种
结果符合 32 位符号整数
思路
这是⼀道典型的背包问题，⼀看到钱币数量不限，就知道这是⼀个完全背包。
但本题和纯完全背包不⼀样，纯完全背包是能否凑成总⾦额，⽽本题是要求凑成总⾦额的个数！
注意题⽬描述中是凑成总⾦额的硬币组合数，为什么强调是组合数呢？
例如示例⼀：
5 = 2 + 2 + 1
5 = 2 + 1 + 2
这是⼀种组合，都是 2 2 1。
如果问的是排列数，那么上⾯就是两种排列了
组合不强调元素之间的顺序，排列强调元素之间的顺序
我为什么要介绍这些呢，因为这和下⽂讲解遍历顺序息息相关!
动规五步曲来分析如下：
- 确定dp数组以及下标的含义
dp[j]：凑成总⾦额j的货币组合数为dp[j]
- 确定递推公式
dp[j] （考虑coins[i]的组合总和） 就是所有的dp[j - coins[i]]（不考虑coins[i]）相加。
所以递推公式：dp[j] += dp[j - coins[i]];
- dp数组如何初始化
⾸先dp[0]⼀定要为1，dp[0] = 1是 递归公式的基础。
从dp[i]的含义上来讲就是，凑成总⾦额0的货币组合数为1。
下标⾮0的dp[j]初始化为0，这样累计加dp[j - coins[i]]的时候才不会影响真正的dp[j]
- 确定遍历顺序
本题中我们是外层for循环遍历物品（钱币），内层for遍历背包（⾦钱总额），还是外层for遍历背包（⾦钱总额），内层for循环遍历物品（钱币）呢？
纯完全背包的两个for循环的先后顺序都是可以的。
但本题就不⾏了！
因为纯完全背包求得是能否凑成总和，和凑成总和的元素有没有顺序没关系，即：有顺序也⾏，没有顺序也⾏！
⽽本题要求凑成总和的组合数，元素之间要求没有顺序。
所以纯完全背包是能凑成总结就⾏，不⽤管怎么凑的。
本题是求凑出来的⽅案个数，且每个⽅案个数是为组合数。
先来看 外层for循环遍历物品（钱币），内层for遍历背包（⾦钱总额）的情况。
for (int i = 0; i < coins.size(); i++) { // 遍历物品
for (int j = coins[i]; j <= amount; j++) { // 遍历背包容量
dp[j] += dp[j - coins[i]];
}
}
假设：coins[0] = 1，coins[1] = 5。
那么就是先把1加⼊计算，然后再把5加⼊计算，得到的⽅法数量只有{1, 5}这种情况。⽽不会出现{5, 1}的情况。
所以这种遍历顺序中dp[j]⾥计算的是组合数！
如果把两个for交换顺序，代码如下：
for (int j = 0; j <= amount; j++) { // 遍历背包容量
for (int i = 0; i < coins.size(); i++) { // 遍历物品
if (j - coins[i] >= 0) dp[j] += dp[j - coins[i]];
}
}
背包容量的每⼀个值，都是经过 1 和 5 的计算，包含了{1, 5} 和 {5, 1}两种情况
此时dp[j]⾥算出来的就是排列数！
-
举例推导dp数组
输⼊: amount = 5, coins = [1, 2, 5] ，dp状态图如下
image.png
最后红⾊框dp[amount]为最终结果。
class Solution {
public:
int change(int amount, vector& coins) {
vector dp(amount + 1, 0);
dp[0] = 1;
for (int i = 0; i < coins.size(); i++) { // 遍历物品
for (int j = coins[i]; j <= amount; j++) { // 遍历背包
dp[j] += dp[j - coins[i]];
}
}
return dp[amount];
}
};
小结
如果求组合数就是外层for循环遍历物品，内层for遍历背包。
如果求排列数就是外层for遍历背包，内层for循环遍历物品。