day20
01背包理论基础
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 的子集。
- 背包中每一个元素是不可重复放入。
- 确定dp数组以及下标的含义
01背包中，dp[j] 表示： 容量为 j 的背包，所背的物品价值可以最大为 dp[j]。
套到本题，dp[j] 表示 背包总容量是 j，最大可以凑成 j 的子集总和为 dp[j]。
- 确定递推公式
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]);
- dp数组如何初始化
在01背包，一维dp如何初始化，已经讲过，
从dp[j]的定义来看，首先dp[0]一定是0。
如果题目给的价值都是正整数那么非0下标都初始化为0就可以了，如果题目给的价值有负数，那么非0下标就要初始化为负无穷。
这样才能让dp数组在递归公式的过程中取的是最大的价值，而不是被初始值覆盖了。
本题题目中 只包含正整数的非空数组，所以非0下标的元素初始化为0就可以了。
- 确定遍历顺序
如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！
- 举例推导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]。
- 确定dp数组以及下标的含义
dp[j]表示容量（这里说容量更形象，其实就是重量）为j的背包，最多可以背dp[j]这么重的石头。
- 确定递推公式
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] 的背包最大所背重量。
- dp数组如何初始化
因为重量都不会是负数，所以dp[j]都初始化为0就可以了，这样在递归公式 dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]); 中 dp[j] 才不会被初始值所覆盖。
- 确定遍历顺序
如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！
- 举例推导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 的背包，有几种方法 ?
- 确定dp数组以及下标的含义
dp[j] 表示：填满j（包括j）这么大容积的包，有dp[j]种方法
也可以使用二维dp数组来求解本题，dp[i][j]：使用 下标为[0, i]的nums[i]能够凑满j（包括j）这么大容量的包，有 dp[i][j] 种方法
- 确定递推公式
填满容量为 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数组如何初始化
从递归公式可以看出，在初始化的时候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]] 推导出来。
- 确定遍历顺序
我们讲过对于01背包问题一维dp的遍历，nums放在外循环，target在内循环，且内循环倒序。
- 举例推导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];
}
}
