代码随想录Day35：动态规划（背包问题 二维 一维、分割等和子集）
一、实战
01背包问题 二维
46. 携带研究材料（第六期模拟笔试）
背包问题暴力解法：因为每个物品其实就两个状态：取or不取，相当于01，所以如果是n个物品，那时间复杂度就是2^n
背包问题动态规划解法（二维）：dp[i][j]数组的含义是下标为0-i的物品任取，放进容量为j的背包里所能放的最大价值；递推公式，当前状态取决于放不放当前物品i
-
不放物品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数组初始化，从递推公式我们可以发现需要正上方或者左上方的，所以初始部分如下图。或者解释从dp[i][j]的定义出发，如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为0。状态转移方程 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 可以看出i 是由 i-1 推导出来，那么i为0的时候就一定要初始化。很明显当 j < weight[0]的时候，dp[0][j] 应该是 0，因为背包容量比编号0的物品重量还小。当j >= weight[0]时，dp[0][j] 应该是value[0]，因为背包容量放足够放编号0物品。
遍历顺序，可以看出，有两个遍历的维度：物品与背包重量，先遍历 物品还是先遍历背包重量呢？在二维数组中，都可以，先遍历物品更好理解；但是滚动数组不可以。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]公式的推导！但先遍历物品再遍历背包这个顺序更好理解。其实背包问题里，两个for循环的先后循序是非常有讲究的，理解遍历顺序其实比理解推导公式难多了。
举例推导DP数组
package org.example.DP;import java.util.Scanner;public class package01_km46 {public static void main(String[] args) {// 创建一个 Scanner 对象，用于从控制台读取输入Scanner scanner = new Scanner(System.in);// 读取物品数量 n 和背包最大承重 bagweightint n = scanner.nextInt(); // 物品个数int bagweight = scanner.nextInt(); // 背包容量// 定义两个数组，分别存储每个物品的重量和价值int[] weight = new int[n]; // weight[i] 表示第 i 个物品的重量int[] value = new int[n]; // value[i] 表示第 i 个物品的价值// 读取每个物品的重量for (int i = 0; i < n; ++i) {weight[i] = scanner.nextInt();}// 读取每个物品的价值for (int j = 0; j < n; ++j) {value[j] = scanner.nextInt();}// 定义动态规划二维数组 dp[i][j]// dp[i][j] 表示：从前 i+1 个物品中选择（即考虑第 0 到第 i 个物品），// 在背包容量为 j 的情况下，能获得的最大价值int[][] dp = new int[n][bagweight + 1];// 第一步：初始化第一行（即只考虑第一个物品）// 当背包容量 j >= 第一个物品的重量 weight[0] 时，// 就可以把第一个物品放进去，此时价值就是 value[0]// 否则放不进去，价值为 0（数组默认值就是 0，所以不用处理小于的情况）for (int j = weight[0]; j <= bagweight; j++) {dp[0][j] = value[0];}// 第二步：填表（状态转移）// 从第二个物品开始（i = 1），遍历每一个物品for (int i = 1; i < n; i++) {// 遍历背包容量从 0 到 bagweightfor (int j = 0; j <= bagweight; j++) {// 如果当前背包容量 j 小于第 i 个物品的重量，无法放入该物品if (j < weight[i]) {// 只能继承上一行的结果：不选第 i 个物品dp[i][j] = dp[i - 1][j];} else {// 否则有两种选择：// 1. 不选第 i 个物品,价值是 dp[i-1][j]// 2. 选第 i 个物品,价值是 dp[i-1][j - weight[i]] + value[i]// 取两者中的最大值dp[i][j] = Math.max(dp[i - 1][j], // 不选dp[i - 1][j - weight[i]] + value[i] // 选);}}}// dp[n-1][bagweight] 表示：考虑所有 n 个物品，在背包容量为 bagweight 时的最大价值System.out.println(dp[n - 1][bagweight]);// 关闭 scanner（可选，但建议用一下）scanner.close();}
}01背包问题 一维
46. 携带研究材料（第六期模拟笔试）
思路：将二维数组压缩为一维数组，把上一行复制下来进行计算
dp数组含义：dp[j]容量为j的背包所能装的最大价值
递推公式：dp[j]=max{dp[j]，dp[j - weight[i]] + value[i]}，其实就是把前面第一个维度移走
dp数组初始化：相对简单，dp[0]=0
遍历顺序：
二维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]并不会被覆盖！
再来看看两个嵌套for循环的顺序，代码中是先遍历物品嵌套遍历背包容量，那可不可以先遍历背包容量嵌套遍历物品呢？不可以！因为一维dp的写法，背包容量一定是要倒序遍历（原因上面已经讲了），如果遍历背包容量放在上一层，那么每个dp[j]就只会放入一个物品，即：背包里只放入了一个物品。所以一维dp数组的背包在遍历顺序上和二维其实是有很大差异的！
import java.util.Scanner;public class Main {public static void main(String[] args) {// 创建 Scanner 对象，用于从标准输入读取数据Scanner scanner = new Scanner(System.in);int M = scanner.nextInt(); // 物品数量int N = scanner.nextInt(); // 背包最大容量// 定义两个数组，分别存储每种材料的空间占用和价值int[] costs = new int[M]; // costs[i] 表示第 i 种材料占用的空间int[] values = new int[M]; // values[i] 表示第 i 种材料的价值// 读取每种材料的空间占用（即重量）for (int i = 0; i < M; i++) {costs[i] = scanner.nextInt();}// 读取每种材料的价值for (int j = 0; j < M; j++) {values[j] = scanner.nextInt();}// 定义 dp 数组，dp[j] 表示：在容量为 j 的背包中，能获得的最大价值// 初始时所有 dp[j] = 0，表示没有物品时价值为 0int[] dp = new int[N + 1]; // 索引从 0 到 N，共 N+1 个状态// 外层循环：遍历每一个物品（研究材料）// i 从 0 到 M-1，表示当前考虑第 i 个物品for (int i = 0; i < M; i++) {// 内层循环：倒序遍历背包容量 j// 从 j = N（最大容量）递减到 costs[i]// 为什么倒序？要确保状态转移时使用的是“上一轮”的数据// 如果正序遍历，会导致同一个物品被重复选择// 倒序可以保证dp[j - costs[i]]是基于前 i-1 个物品计算出的结果for (int j = N; j >= costs[i]; j--) {// 状态转移方程// 对于当前容量 j，我们有两个选择：// 1. 不选第 i 个物品，价值仍是 dp[j]// 2. 选第 i 个物品，价值是 dp[j - costs[i]] + values[i]// 前提是 j >= costs[i]dp[j] = Math.max(dp[j], // 不选当前物品dp[j - costs[i]] + values[i] // 选当前物品);}}System.out.println(dp[N]);// 关闭 Scanner，释放资源scanner.close();}
}416分割等和子集
416. 分割等和子集 - 力扣（LeetCode）
dp[j] 表示： 容量（所能装的重量）为j的背包，所背的物品价值最大可以为dp[j]。
递推公式：原先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]);
如何初始化：从dp[j]的定义来看，首先dp[0]一定是0。如果题目给的价值都是正整数那么非0下标都初始化为0就可以了，如果题目给的价值有负数，那么非0下标就要初始化为负无穷。这样才能让dp数组在递推的过程中取得最大的价值，而不是被初始值覆盖了。
确定遍历顺序：如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！
举例推导DP数组：dp[j]的数值一定是小于等于j的。
如果dp[j] == j 说明，集合中的子集总和正好可以凑成总和j，理解这一点很重要。最后dp[11] == 11，说明可以将这个数组分割成两个子集，使得两个子集的元素和相等。
public boolean canPartition(int[] nums) {// 边界判断：如果数组为空或长度为0，无法分割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;// dp[j] 表示：在容量为 j 的背包中，能装下的最大数值和// 目标：dp[target] 是否等于 targetint[] dp = new int[target + 1]; // 索引从 0 到 target// 外层循环：遍历每一个数字for (int i = 0; i < n; i++) {// 内层循环：倒序遍历背包容量 j 从 target 到 nums[i]// 必须倒序，防止同一个物品被多次选择， 0-1 背包特性for (int j = target; j >= nums[i]; j--) {// 状态转移方程：对于当前容量 j，有两个选择：// 1. 不选 nums[i]，最大和仍是 dp[j]// 2. 选 nums[i]，最大和是 dp[j - nums[i]] + nums[i]// 取两者最大值dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);}// 剪枝优化：提前终止// 每处理完一个数字后，立即检查是否已经达到了目标。如果 dp[target] 已经等于 target，说明已经找到了一个子集和为 target。可以直接返回 true，无需继续遍历剩下的数字if (dp[target] == target) {return true;}}// 最终判断：是否恰好装满容量为 target 的背包return dp[target] == target;
}