day42｜01背包问题，滚动数组，416. 分割等和子集

01背包问题

01背包就是有一个背包，限制容量/重量，且每个物品只能放一次，问最大价值。

二维

1. 确定dp数组以及下标的含义
   dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少
2. 确定递推公式
   基于i-1推出当前的dp[i][j] 有两种可能：
   不放物品i dp[i - 1][j]
   放物品i dp[i - 1][j - weight[i]] + value[i]

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

3. dp数组如何初始化
   当j >= weight[0]时，dp[0][j] 应该是value[0]，因为背包容量放足够放编号0物品。
   
   但从怎么推出dp[i][j]可知，其他每个值从上方，或者左上方得，所以和当前初始化的值无关，可初始化成任意数
4. 确定遍历顺序
   都可以，这里先遍历物品再遍历背包重量。
5. 举例推导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]);

    }
} 

01背包滚动数组

dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
其实就是把dp[i - 1]那一层拷贝到dp[i]上，就是将上一层重复利用，直接拷贝到当前层。因为实际上i-1这一层存储的值，只有在推论i的时候才需要。这就成了一个滚动的数组。（很形象哎！）
dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。

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

同时遍历顺序也不一样，

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]);

    }
}

这里是倒序遍历，我的理解是因为每次更新的操作是，拷贝上一层到这一层，然后当前这一格的值二维中应该从上方和左上方获得，即一维中从当前格和左方的格中获得。所以只能从前向后，要不值就会被覆盖了，遍历到最后就是已经改变过的值。
也有说法是倒序遍历是为了保证物品i只被放入一次，也就是到最后一格比较的时候，实际上他左边格的值是已经放过物品i的情况。

01背包的标准解法

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. 分割等和子集

输入: [1, 5, 11, 5]
输出: true
解释: 数组可以分割成 [1, 5, 5] 和 [11].

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

如果dp[j] == j 说明，集合中的子集总和正好可以凑成总和j，理解这一点很重要

首先，确定本题为01背包应用，物品是nums[i]，重量是nums[i]，价值也是nums[i]，背包体积是sum/2，每个元素也就是物品，他的重量和价值都为这个元素的数值！ 每个元素只能放入一次，看能不能装满这个背包（能装满就说明true）
注意向下取整的情况

class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        if (sum % 2 == 1) { // 注意一定没有解！！！
            return false;
        }
        int[] dp = new int[sum/2+1];
        for (int i = 0; i < nums.length; i++) {
            for (int j = sum/2; j >= nums[i]; j--) { // 每一个元素一定是不可重复放入，所以从大到小遍历
                dp[j] = Math.max(dp[j], dp[j-nums[i]]+nums[i]);
            }
        }
        if (dp[dp.length-1] == sum/2) return true; // 集合中的元素正好可以凑成总和target
        return false;
    }
}