day20

day20

01背包理论基础

• 初始化后的dp数组

dp数组的取值都是从两个方向递推过来的

• 先遍历物品再遍历背包

• 先遍历背包再遍历物品

代码实现

/**
 * dp[i][j]表示编号[0,i]之间的任意物品，任取放进容量为j的背包中的最大价值
 * 不放物品i：dp[i-1][j]
 *          i-1表示不放(跳过)这个物品，那么容量j就不会改变
 * 放物品i：dp[i-1][j-weight[i]] + value[i]
 * dp[i-1][j-weight[i]]：i-1表示放了物品i之后，还剩下j-weight[i]的容量可以放其他物品，
 *                       剩下空间能得到的最大值是dp[i-1][j-weight[i]]
 * 
 * 所以，dp[i][j] = Math.max(dp[i-1][j], dp[i-1][j-weight[i]] + value[i])
 *
 * @author xiexu
 * @create 2022-04-04 10:03
 */
public class _01背包理论基础 {

    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数组：dp[i][j]表示背包容量为j时，前i个物品能获得的最大价值
        int[][] dp = new int[weight.length + 1][bagsize + 1];

        // 初始化：背包容量为0时，能获得的价值都为0
        for (int i = 0; i <= weight.length; i++) {
            dp[i][0] = 0;
        }
        // 初始化：只有物品0时，判断当前背包是否可以放进物品0的重量
        for (int j = weight[0]; j <= bagsize; j++) {
            dp[0][j] = value[0];
        }

        // 遍历顺序：先遍历物品，再遍历背包容量
        for (int i = 1; i <= weight.length; i++) {
            for (int j = 1; j <= bagsize; j++) {
                if (j < weight[i - 1]) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weight[i - 1]] + value[i - 1]);
                }
            }
        }

        // 打印dp数组
        for (int i = 0; i <= weight.length; i++) {
            for (int j = 0; j <= bagsize; j++) {
                System.out.print(dp[i][j] + "\t");
            }
            System.out.println();
        }
    }

}

01背包理论基础 (滚动数组)

代码实现

/**
 * dp[i][j]：表示编号[0,i]之间的任意物品，任取放进容量为j的背包中的最大价值
 * dp[i]：容量为j的背包所能获得的最大价值
 *
 * @author xiexu
 * @create 2022-04-05 19:51
 */
public class _01背包理论基础_滚动数组 {

    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数组：dp[j]表示背包容量为j时，能获得的最大价值
        int[] dp = new int[bagsize + 1];

        // 遍历顺序：先遍历物品，再遍历背包容量
        for (int i = 0; i < weight.length; i++) {
            for (int j = bagsize; j >= weight[i]; j--) {
                dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
            }
        }

        //打印dp数组
        for (int j = 0; j <= bagsize; 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
解释：数组不能分割成两个元素和相等的子集。

提示：

1 <= nums.length <= 200
1 <= nums[i] <= 100

二维dp (容易理解)

思路

给一个可装载重量为 sum / 2 的背包和 N 个物品，每个物品的重量为 nums[i]。现在让你装物品，是否存在一种装法，能够恰好将背包装满 ?

第一步要明确两点，「状态」和「选择」。

• 这个前文 背包问题 已经详细解释过了，状态就是「背包的容量」和「可选择的物品」，选择就是「装进背包」或者「不装进背包」。

第二步要明确 dp 数组的定义。

• 按照背包问题的套路，可以给出如下定义：
• dp[i][j] = x 表示，对于前 i 个物品，当前背包的容量为 j 时，若 x 为 true，则说明可以恰好将背包装满，若 x 为 false，则说明不能恰好将背包装满。
• 比如说，如果 dp[4][9] = true，其含义为：对于容量为 9 的背包，若只是用前 4 个物品，可以有一种方法把背包恰好装满。
• 或者说对于本题，含义是对于给定的集合中，若只对前 4 个数字进行选择，存在一个子集的和可以恰好凑出 9。
• 根据这个定义，我们想求的最终答案就是 dp[N][sum/2]，base case 就是 dp[..][0] = true 和 dp[0][..] = false，因为背包没有空间的时候，就相当于装满了，而当没有物品可选择的时候，肯定没办法装满背包。

第三步，根据「选择」，思考状态转移的逻辑。

• 回想刚才的 dp 数组含义，可以根据「选择」对 dp[i][j] 得到以下状态转移：
• 如果不把 nums[i] 算入子集，或者说你不把这第 i 个物品装入背包，那么是否能够恰好装满背包，取决于上一个状态 dp[i-1][j]，继承之前的结果。
• 如果把 nums[i] 算入子集，或者说你把这第 i 个物品装入了背包，那么是否能够恰好装满背包，取决于状态 dp[i-1][j-nums[i-1]]。
• 首先，由于 i 是从 1 开始的，而数组索引是从 0 开始的，所以第 i 个物品的重量应该是 nums[i-1]，这一点不要搞混。
• dp[i - 1][j-nums[i-1]] 也很好理解：你如果装了第 i 个物品，就要看背包的剩余重量 j - nums[i-1] 限制下是否能够被恰好装满。

代码实现

/**
 * https://leetcode-cn.com/problems/partition-equal-subset-sum/
 * dp[i][j]：对于前i个数，能否恰好装进容量为j的背包
 *
 * @author xiexu
 * @create 2022-04-05 21:25
 */
public class _416_分割等和子集 {

    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        // 和为奇数时，不可能划分成两个和相等的集合
        if (sum % 2 != 0) {
            return false;
        }
        int n = nums.length;
        sum = sum / 2;
        boolean[][] dp = new boolean[n + 1][sum + 1];
        // dp初始化，如果当前背包容量是0，则对于任意物品都可以满足
        for (int i = 0; i <= n; i++) {
            dp[i][0] = true;
        }

        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= sum; j++) {
                if (j - nums[i - 1] < 0) {
                    // 背包容量不足，不能装入第 i 个物品
                    dp[i][j] = dp[i - 1][j];
                } else {
                    // 装入或不装入背包
                    dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i - 1]];
                }
            }
        }
        return dp[n][sum];
    }

}

一维dp (速度更快)

思路

只有确定了如下四点，才能把01背包问题套到本题上来。

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

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

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

套到本题，dp[j] 表示 背包总容量是 j，最大可以凑成 j 的子集总和为 dp[j]。

1. 确定递推公式

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

1. dp数组如何初始化

在01背包，一维dp如何初始化，已经讲过，

从dp[j]的定义来看，首先dp[0]一定是0。

如果题目给的价值都是正整数那么非0下标都初始化为0就可以了，如果题目给的价值有负数，那么非0下标就要初始化为负无穷。

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

本题题目中 只包含正整数的非空数组，所以非0下标的元素初始化为0就可以了。

1. 确定遍历顺序

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

1. 举例推导dp数组

dp[i]的数值一定是小于等于i的。

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

用例1，输入[1,5,11,5] 为例，如图：

最后dp[11] == 11，说明可以将这个数组分割成两个子集，使得两个子集的元素和相等。

代码实现

/**
 * https://leetcode-cn.com/problems/partition-equal-subset-sum/
 * dp[j]表示 背包总容量是j，最大可以凑成j的子集总和为dp[j]
 *
 * @author xiexu
 * @create 2022-04-05 21:25
 */
public class _416_分割等和子集_一维数组 {

    public boolean canPartition(int[] nums) {
        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;
        int[] dp = new int[target + 1];
        for (int i = 0; i < n; i++) {
            for (int j = target; j >= nums[i]; j--) {
                // 物品 i 的重量是 nums[i]，其价值也是 nums[i]
                dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);
            }
        }
        return dp[target] == target;
    }

}

1049. 最后一块石头的重量 II

力扣题目链接

题目

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

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

如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。

示例 1：

输入：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]，这就是最优值。

示例 2：

输入：stones = [31,26,33,21,40]
输出：5

提示：

1 <= stones.length <= 30
1 <= stones[i] <= 100

一维dp (速度更快)

思路

本题物品的重量为 store[i]，物品的价值也为 store[i]。

对应着01背包里的物品重量 weight[i] 和 物品价值 value[i]。

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

dp[j]表示容量（这里说容量更形象，其实就是重量）为j的背包，最多可以背dp[j]这么重的石头。

1. 确定递推公式

01背包的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

本题则是：dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);

其中，dp[j - stones[i]] 为 容量为 j - stones[i] 的背包最大所背重量。

1. dp数组如何初始化

因为重量都不会是负数，所以dp[j]都初始化为0就可以了，这样在递归公式 dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]); 中 dp[j] 才不会被初始值所覆盖。

1. 确定遍历顺序

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

1. 举例推导dp数组

举例，输入：[2,4,1,1]，此时 target = (2 + 4 + 1 + 1)/2 = 4 ，dp数组状态图如下：

最后 dp[target] 里是容量为 target 的背包所能背的最大重量。

那么分成两堆石头，一堆石头的总重量是 e，另一堆就是 sum - dp[target]。

在计算 target 的时候，target = sum / 2 因为是向下取整，所以 sum - dp[target] 一定是大于等于dp[target] 的。

那么相撞之后剩下的最小石头重量就是 (sum - dp[target]) - dp[target]。

代码实现

/**
 * https://leetcode-cn.com/problems/last-stone-weight-ii/
 * dp[j]表示容量（这里说容量更形象，其实就是重量）为j的背包，最多可以背dp[j]这么重的石头
 *
 * @author xiexu
 * @create 2022-04-05 22:11
 */
public class _1049_最后一块石头的重量_II {

    public int lastStoneWeightII(int[] stones) {
        int sum = 0;
        for (int stone : stones) {
            sum += stone;
        }
        int target = sum >> 1;
        // 初始化dp数组
        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]);
            }
        }
        return (sum - dp[target]) - dp[target];
    }

}

二维dp (容易理解)

代码实现

/**
 * https://leetcode-cn.com/problems/last-stone-weight-ii/
 * dp[i][j]：可以放(0-i)块石头，背包容量为j的情况下背包中的最大重量
 *
 * @author xiexu
 * @create 2022-04-05 22:11
 */
public class _1049_最后一块石头的重量_II_二维dp {

    public int lastStoneWeightII(int[] stones) {
        int n = stones.length;
        int sum = 0;
        for (int stone : stones) {
            sum += stone;
        }
        int target = sum / 2;
        int[][] dp = new int[n][target + 1];
        // dp[i][0] 默认初始化为0
        // dp[0][j] 取决于stones[0]
        for (int j = stones[0]; j <= target; j++) {
            dp[0][j] = stones[0];
        }
        for (int i = 1; i < stones.length; i++) {
            for (int j = 1; j <= target; j++) {
                if (j < stones[i]) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - stones[i]] + stones[i]);
                }
            }
        }
        return (sum - dp[n - 1][target]) - dp[n - 1][target];
    }

}

494. 目标和

力扣题目链接

题目

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

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

例如，nums = [2, 1] ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串联起来得到表达式 “+2-1” 。
返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

示例 1：

输入：nums = [1,1,1,1,1], target = 3
输出：5
解释：一共有 5 种方法让最终目标和为 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
+1 + 1 + 1 + 1 - 1 = 3

示例 2：

输入：nums = [1], target = 1
输出：1

提示：

1 <= nums.length <= 20
0 <= nums[i] <= 1000
0 <= sum(nums[i]) <= 1000
-1000 <= target <= 1000

一维dp

思路

sum(A) - sum(B) = target
sum(A) = target + sum(B)
sum(A) + sum(A) = target + sum(B) + sum(A)
2 * sum(A) = target + sum(nums)
sum(A) = (target + sum(nums)) / 2

把原问题转化为：nums 中存在几个子集 A，使得 A 中元素的和为 (target + sum(nums)) / 2 ?

对应到 01背包问题也就是：装满容量为 (target + sum(nums)) / 2 的背包，有几种方法 ?

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

dp[j] 表示：填满j（包括j）这么大容积的包，有dp[j]种方法

也可以使用二维dp数组来求解本题，dp[i][j]：使用 下标为[0, i]的nums[i]能够凑满j（包括j）这么大容量的包，有 dp[i][j] 种方法

1. 确定递推公式

填满容量为 j - nums[i] 的背包，有 dp[j - nums[i]] 种方法。

那么只要搞到 nums[i] 的话，凑成dp [j] 就有 dp[j - nums[i]] 种方法。

例如：dp[j]，j 为5，

• 已经有一个1（nums[i]） 的话，有 dp[4]种方法 凑成 dp[5]。
• 已经有一个2（nums[i]） 的话，有 dp[3]种方法 凑成 dp[5]。
• 已经有一个3（nums[i]） 的话，有 dp[2]中方法 凑成 dp[5]
• 已经有一个4（nums[i]） 的话，有 dp[1]中方法 凑成 dp[5]
• 已经有一个5 （nums[i]）的话，有 dp[0]中方法 凑成 dp[5]

那么凑整dp[5]有多少方法呢，也就是把 所有的 dp[j - nums[i]] 累加起来。

所以求组合类问题的公式，都是类似这种：

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

1. 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]] 推导出来。

1. 确定遍历顺序

我们讲过对于01背包问题一维dp的遍历，nums放在外循环，target在内循环，且内循环倒序。

1. 举例推导dp数组

输入：nums = [1, 1, 1, 1, 1]，target = 3

bagSize = (target + sum) / 2 = (3 + 5) / 2 = 4

dp数组状态变化如下：

代码实现

/**
 * https://leetcode-cn.com/problems/target-sum/
 *
 * @author xiexu
 * @create 2022-04-05 23:30
 */
public class _494_目标和_动态规划 {

    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        // target的绝对值大于sum，是没有方案的
        if (Math.abs(target) > sum) {
            return 0;
        }
        // 例如sum是5，target是2的话也是无解的
        if ((target + sum) % 2 == 1) {
            return 0;
        }
        int bagSize = (target + sum) / 2;
        int[] dp = new int[bagSize + 1];
        dp[0] = 1;
        for (int i = 0; i < nums.length; i++) {
            for (int j = bagSize; j >= nums[i]; j--) {
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[bagSize];
    }

}

回溯算法

代码实现

/**
 * https://leetcode-cn.com/problems/target-sum/
 *
 * @author xiexu
 * @create 2022-04-05 23:30
 */
public class _494_目标和_回溯 {

    int result = 0;

    public int findTargetSumWays(int[] nums, int target) {
        if (nums == null) {
            return 0;
        }
        backtrack(nums, 0, target);
        return result;
    }

    public void backtrack(int[] nums, int i, int remain) {
        if (i == nums.length) {
            if (remain == 0) {
                result++;
            }
            return;
        }

        // 给 nums[i] 选择 '-' 号
        remain += nums[i];
        // 穷举 nums[i + 1]
        backtrack(nums, i + 1, remain);
        // 撤销选择
        remain -= nums[i];

        // 给 nums[i] 选择 '+' 号
        remain -= nums[i];
        // 穷举 nums[i + 1]
        backtrack(nums, i + 1, remain);
        // 撤销选择
        remain += nums[i];
    }

}