01背包问题的拓展运用

纯01背包

        装满背包的最大价值是多少

放入物品i时，装入容量为j的背包的最大价值为dp[i][j]
dp[i][j] = max(dp[i-1][j], dp[i-1][j-weight[i]]+value[i]);

01背包之滚动数组

装入物品i时，装入背包的最大价值为dp[i]
dp[i] = max(dp[j], dp[j-weight[i]]+value[i]);

        遍历顺序

for(int i = 0; i < 物品数量; i++){
    for(int j = weight; j >= weight[i]; j--){
        dp[j] = Math.max(dp[j], dp[j-weight[i]]+value[i]);
    }
}

        第一层for循环遍历的是物品，第二层for循环遍历的是背包。和经典01背包相比，不同之处在于滚动数组在遍历背包的时候需要倒叙遍历，这么做的原因是保证每个物品只被添加一次。

        同时两层for循环不能颠倒，必须是先遍历物品，再遍历背包。

拓展运用一：分割等和子集

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

        若使用动态规划来解决该题，我们可以将其抽象成背包问题。即：数组中的每个元素都是物品，问容量为所有元素之和的一半的背包是否能被装满。

        对应leetcode第416题。

nums = [1,5,11,5]，元素之和为22
每一个元素就是物品的重量，也是物品的价值，问是否能装满容量为11的背包（装满即为最大价值）。

        与01背包问题相比：几乎一致，第一层for循环遍历元素，第二层for循环遍历背包（集合）。只需将dp公式中的 weight[i] 和 value[i] 都换成 nums[i] 即可。

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

        具体代码实现如下：

class Solution {
    public boolean canPartition(int[] nums) {
        Arrays.sort(nums);
        int target = 0;
        for (int i = 0; i < nums.length; i++) {
            target += nums[i];
        }
        if(target % 2 != 0){
            return false;
        }else target /= 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]);
            }
        }
        if(dp[target] == target ){
            return true;
        }else return false;
    }
}

核心思想：能否装满背包

拓展运用二：最后一块石头的重量Ⅱ

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。

每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

• 如果 x == y，那么两块石头都会被完全粉碎；
• 如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。

最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。

        对应leetcode第1049题。

输入：stones = [2,7,4,1,8,1]
输出：1
解释：
组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]，
组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]，
组合 2 和 1，得到 1，所以数组转化为 [1,1,1]，
组合 1 和 1，得到 0，所以数组转化为 [1]，这就是最优值。

        不断地取两块石头进行撞击，取集合内的最小值，可以将其化作两堆石头，若两堆石头相撞可得到最小值，那么就是最优值。

        如果把石头分成两堆重量等大或重量相近的石头，那么相撞之后余剩的质量为最小。将其抽象成背包问题，即总重量为 sum ，能装入背包容量为 sum/2 的最大重量是多少。

能装满背包为sum/2的最大重量为dp[j]，数组元素的值即是物品重量，也是物品价值。
此时问题和01背包问题一致，dp公式如下：
dp[j]=Math.max(dp[j], dp[j-stones[i]] + stones[i]);

        具体代码实现如下：

class Solution {
    public int lastStoneWeightII(int[] stones) {
        int target = 0;
        int sum = 0;
        for (int i = 0; i < stones.length; i++) {
            sum += stones[i];
        }
        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]);
            }
        }
        int rest = sum -dp[target];
        return Math.abs(dp[target] - rest);
    }
}

核心思想：给一个背包，能装多少装多少，求背包能装入的最大重量（质量）

拓展运用三：目标和        

给你一个整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ：

• 例如，nums = [2, 1] ，可以在 2 之前添加 '+' ，在 1 之前添加 '-' ，然后串联起来得到表达式 "+2-1" 。

返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

        对应leetcode第494题

        给一个数组，对于里面的元素选择 ‘+’ 或者 ‘-’ 。对于这类两种选择的问题，实际上使用递归算法会更加直接快捷，先选择 ‘+’，若不合适则回溯去选择‘-’ 。但是本题使用回溯算法会占用大量的时间和内存，因此不建议使用。

        回溯算法代码实现如下：

public class 目标和m {

    int num = 0;

    public int findTargetSumWays(int[] nums, int target) {
        backtrack(nums, target, 0, 0);
        return num;
    }

    public void backtrack(int[] nums, int target, int sum, int startIndex){
        if(startIndex == nums.length){
            if(sum == target){
                num += 1;
            }
            return;
        }
        //选择+
        sum += nums[startIndex];
        backtrack(nums, target, sum, startIndex+1);
        //不符合被return，撤销选择，并选择-
        sum -= nums[startIndex] * 2;
        backtrack(nums, target, sum, startIndex+1);
        //不符合被return，撤销选择
        sum += nums[startIndex];
    }
}

        对于此题，我们可以通过最后一块石头的重量Ⅱ得到一点灵感：将选择‘+’的元素分成一个集合，那么余剩的元素就选择‘-’，再由集合‘+’的总和减去集合‘-’的总和，即可得到目标值，因此可以得出以下结论：

设集合‘+’的总和为add，集合‘-’的总和为reduce，所有元素的总和为sum
那么add-reduce = target，add-(sum-add)=target
    ==> add = (target+sum)/2

        可以将其抽象成01背包问题：即当背包容量为add时，装满背包有多少种方法。由于问题不再是询问背包的重量或者质量，因此dp公式没有办法直接套用，但是遍历仍然和01背包问题相同：第一层for循环遍历元素，第二层for循环遍历背包。

        对于dp公式的推导，可以从初始化入手：

        假设背包的容量为5，递推公式为dp[j]，即装满容量为j的背包有dp[j]种方法。

• 当背包内有一个重量为1的物品时，有dp[4]种方法可以装满背包。（容量5减去物品重量1）
• 当背包内有一个重量为2的物品时，有dp[3]种方法可以装满背包。
• 当背包内有一个重量为3的物品时，有dp[2]种方法可以装满背包。
• 当背包内有一个重量为4的物品时，有dp[1]种方法可以装满背包。
• 当背包内有一个重量为5的物品时，有dp[0]种方法可以装满背包

        此处和爬楼梯一题十分相似，每次爬一层或两层，爬上第 i 层台阶有dp[i] = dp[i-1] + dp[i-1]种方法。那么此题，装满背包容量为5的方法，也可以由之前装满背包的方法相加。

        即：dp[5] = d[4] + dp[3] + dp[2] + dp[1] + dp[0]

        因此dp公式为：

dp[j] += dp[j - nums[i]];

        代码实现如下：

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) sum += nums[i];
	//如果target过大 sum将无法满足
        if ( target < 0 && sum < -target) return 0;
        if ((target + sum) % 2 != 0) return 0;
        int size = (target + sum) / 2;
        if(size < 0) size = -size;
        int[] dp = new int[size + 1];
        dp[0] = 1;
        for (int i = 0; i < nums.length; i++) {
            for (int j = size; j >= nums[i]; j--) {
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[size];
    }
}

核心思想：有多少种方法把背包装满

一和零：背包里最多有多少个物品