东莞做阀门的网站/湖北网站推广

01背包问题

        有n件物品和一个最多能背重量为w的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

例：背包最大重量为4。

物品为：

	重量	价值
物品0	1	15
物品1	3	20
物品2	4	30

 问背包能背的物品最大价值是多少？

一、二维dp数组01背包

1、确定dp数组以及下标的含义

dp[i][j]：在下标[0,i]的物品任取，放进容量为j的背包，价值总和最大是多少

2、确定递推公式

• 如果背包重量小于物品 i 的重量，那么就不把 i 放进背包里，可得

所以递推公式为：

dp[i][j]=dp[i-1][j]

• 如果背包重量大于物品i的重量，分类讨论：
  • 放物品i：dp[i][j]=dp[i-1][j-weight[i]]+value[i]
  • 不放物品i：dp[i][j]=dp[i-1][j]

 所以递推公式为：

dp[i][j]=Math.max(dp[i-1][j-weight[i]]+value[i],dp[i-1][j])

3、dp数组初始化

① 根据dp的递推公式dp[i-1][j]可知，i 由i-1推导出来(上面的元素)，所以要初始化i=0时的数组元素，即dp[0][j]，存放编号为0的物品时，放入各个重量的状态，最大价值总和。

当weight[0]>j 时，dp[0][j]=0。背包容量比编号0的物品重量还小

当weight[0]<=j 时，dp[0][j]=value[0]。背包容量放足够放编号0物品

② 根据dp[i-1][j-weight[i]]+value[i]可知，j 由j-weight[i] 推导出来(左上角的元素)，所以要初始化j=0时的元素，即dp[i][0]=0，背包重量为0，放不进去，所以最大价值为0。

 其它元素随意赋初始值，因为会被覆盖。

4、确定遍历顺序

先遍历物品（先横向遍历）或者先遍历重量（先遍历纵向）都可以，都可以保证左上方和上方已有值。

5、举例推导dp数组

public class Main {public static void main(String[] args) {int[] weight = {1,3,4};int[] value = {15,20,30};int bagSize = 4;testWeightBagProblem(weight,value,bagSize);}/*** 动态规划获得结果* @param weight  物品的重量* @param value   物品的价值* @param bagSize 背包的容量*/public static void testWeightBagProblem(int[] weight, int[] value, int bagSize){// 创建dp数组int goods = weight.length;  // 获取物品的数量int[][] dp = new int[goods][bagSize + 1];// 初始化dp数组// 创建数组后，其中默认的值就是0//i=0,dp[0][j]for (int j = 0; j <= bagSize; j++) {if (weight[0]>j){dp[0][j]=0;}else if (weight[0]<=j){dp[0][j]=value[0];}}//j=0,dp[i][0]for (int i = 0; i < goods; i++) {dp[i][0] = 0;}// 填充dp数组for (int i = 1; i < weight.length; i++) {for (int j = 1; j <= bagSize; j++) {if (j < weight[i]) {/*** 当前背包的容量都没有当前物品i大的时候，是不放物品i的* 那么前i-1个物品能放下的最大价值就是当前情况的最大价值*/dp[i][j] = dp[i-1][j];} else {/*** 当前背包的容量可以放下物品i* 那么此时分两种情况：*    1、不放物品i*    2、放物品i* 比较这两种情况下，哪种背包中物品的最大价值最大*/dp[i][j] = Math.max(dp[i-1][j] , dp[i-1][j-weight[i]] + value[i]);}}}// 打印dp数组for (int i = 0; i < goods; i++) {for (int j = 0; j <= bagSize; j++) {System.out.print(dp[i][j] + "\t");}System.out.println("\n");}}
}

二、一维dp数组01背包（滚动数组）

行覆盖。把dp[i - 1]那一层拷贝到dp[i]上，只用一维数组dp[j]

1、确定dp数组以及下标的含义

dp[j]：容量为j的背包，所背的物品价值可以最大为dp[j]。

2、一维dp数组的递推公式

• 不放物品 i 时，dp[j]=dp[j]（相当于dp[i-1][j]）
• 放物品 i 时，dp[j]=dp[j-weight[i]]+value[i]

递推公式为：

dp[j]=Math.max(dp[j],dp[j-weight[i]]+value[i])

3、一维dp数组初始化

题目给的价值都是正整数，那么非0下标都初始化为0。dp[j]=0

这样才能让dp数组在递归公式的过程中取的最大的价值，而不是被初始值覆盖了。

4、一维dp数组遍历顺序

① 倒序，背包从大到小，为了保证物品i只被放入一次。

例：物品0的重量weight[0] = 1，价值value[0] = 15

如果正序遍历，假设i=0时

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

tips：假设目前有背包容量为10，可以装的最大价值， 记为g[10]。即将进来的物品重量为6。价值为9。

如果不装该物品，显然背包容量无变化，这里对应二维数组，其实就是取该格子上方的格子复制下来，就是所说的滚动下来，直接g[10[ = g[10]，这两个g[10]要搞清楚，右边的g[10]是上一轮记录的，也就是对应二维数组里上一层的值，而左边是新的g[10]，也就是对应二维数组里下一层的值。

如果装该物品，则背包容量= g[10-6] = g[4] + 9 ，也就是 g[10] = g[4] + 6 ,这里的6显然就是新进来的物品的价值，g[10]就是新记录的，对应二维数组里下一层的值，而这里的g[4]是对应二维数组里上一层的值，通俗的来讲：你要找到上一层也就是上一状态下 背包容量为4时的能装的最大价值，用它来更新下一层的这一状态，也就是加入了价值为9的物品的新状态。

这时候如果是正序遍历会怎么样？g[10] = g[4] + 6 ，这个式子里的g[4]就不再是上一层的了，因为你是正序啊，g[4] 比g[10]提前更新，那么此时程序已经没法读取到上一层的g[4]了，新更新的下一层的g[4]覆盖掉了，这里也就是为啥有题解说一件物品被拿了两次的原因。

② 先遍历物品再遍历背包容量

如果顺序反了，dp[j]就会一直为最大值，最终结果为30，30，30，30，30

5、举例推导dp数组

一维dp，分别用物品0，物品1，物品2 来遍历背包，最终得到结果如下：

public static void main(String[] args) {int[] weight = {1, 3, 4};int[] value = {15, 20, 30};int bagWight = 4;testWeightBagProblem(weight, value, bagWight);}public static void testWeightBagProblem(int[] weight, int[] value, int bagWeight){int wLen = weight.length;//定义dp数组：dp[j]表示背包容量为j时，能获得的最大价值int[] dp = new int[bagWeight + 1];//遍历顺序：先遍历物品，再遍历背包容量for (int i = 0; i < wLen; i++){for (int j = bagWeight; j >= weight[i]; j--){dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);}}//打印dp数组for (int j = 0; j <= bagWeight; j++){System.out.print(dp[j] + " ");}}

---

416. 分割等和子集 

给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

示例 1：

输入：nums = [1,5,11,5]

输出：true

解释：数组可以分割成 [1, 5, 5] 和 [11] 。

示例 2：

输入：nums = [1,2,3,5]

输出：false

解释：数组不能分割成两个元素和相等的子集。

 问题分析：​​​​​​​

• 背包的体积为sum / 2
• 背包要放入的商品（集合里的元素）重量为 元素的数值，价值也为元素的数值
• 背包如果正好装满，说明找到了总和为 sum / 2 的子集。
• 背包中每一个元素是不可重复放入。

 1、确定dp数组以及下标的含义

dp[j]：背包总容量（所能装的总重量）是j，放进物品后，背的最大重量为dp[j]。

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]=0，数组初始化自动赋为0

这样才能让dp数组在递推的过程中取得最大的价值，而不是被初始值覆盖了。

4、确定遍历顺序

如同01滚动数组，使用一维dp，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历

5、举例推导dp数组

若dp[target]==target，说明可以凑成两个总和相等的数组

class Solution {public boolean canPartition(int[] nums) {int sum=0;for (int i=0;i< nums.length;i++){sum=sum+nums[i];}if (sum%2!=0) return false;//如果不是2的倍数，就不能分成两个相等的数组int target=sum/2;int[] dp=new int[target+1];for(int i=0;i< nums.length;i++){for (int j=target;j>=nums[i];j--){dp[j]=Math.max(dp[j],dp[j-nums[i]]+nums[i]);}}return dp[target]==target;//背包的容量和背包的价值都是nums[i]}
}