4.0-1背包问题
有N件物品和一个最多能被重量为W 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。
/**
* 0-1背包问题
* @param w w[index] 当前货物的总重量
* @param v v[index] 当前货物的总价值
* @param index 当前的货物号
* @param alreadyW 0--index 已做出决定，所形成的目前重量
* @param bag 可装的总重量
* @return 返回最大价值
*/
public static int process(int[] w,int[] v,int index,int alreadyW,int bag){
//base case 背高超重了，不能再放物品了
if(alreadyW>bag){
return -1;
}
//没有物品了
if(index==w.length){
return 0;
}
//当前物品不放所获得的最大价值
int p1=process(w,v,index+1,alreadyW,bag);
//当前物品放入背包所获得的最大价值
int p2=process(w,v,index+1,alreadyW+w[index],bag);
int pNext=-1;
if(p2!=-1){
pNext=v[index]+p2;
}
return Math.max(p1,pNext);
}
/**
* 0-1背包问题
* @param w 当前货物的总重量
* @param v 当前货物的总价值
* @param index 当前的货物号
* @param rest 剩余可装入的重量
* @return 返回最大价值
*/
public static int process(int[] w,int[] v,int index,int rest) {
//没有容量了
if (rest == 0) {
return 0;
}
//没有物品了
if (index == w.length) {
return 0;
}
int p1 = process(w, v, index + 1, rest);
int p2 = 0;
//放入当前物品的话，要判段容量是否够
if (rest >= w[index]) {
p2 = v[index] + process(w, v, index + 1, rest - w[index]);
}
return Math.max(p1, p2);
}
public static int bagDp(int[] w,int[] v,int rest){
int N=w.length;
int[][] dp=new int[N+1][rest+1];
for(int i=N-1;i>=0;i--){
for(int j=1;j<=rest;j++){
dp[i][j]=dp[i+1][j];
if(j-w[i]>=0){
dp[i][j]=Math.max(dp[i][j],dp[i+1][j-w[i]]+v[i]);
}
}
}
return dp[0][rest];
}
依然动规五部曲分析一波。
- 确定dp数组以及下标的含义
dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。
- 确定递推公式
再回顾一下dp[i][j]的含义：从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。
那么可以有两个方向推出来dp[i][j]，
- 不放物品i：由dp[i - 1][j]推出
- 放物品i：由dp[i - 1][j - weight[i]]推出，那么dp[i - 1][j - weight[i]] + value[i] （物品i的价值），就是背包放物品i得到的最大价值
所以递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
- dp数组如何初始化
关于初始化，一定要和dp数组的定义吻合，否则到递推公式的时候就会越来越乱。
首先从dp[i][j]的定义出发，如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为0。
此时dp数组初始化情况如图所示：
dp[0][j] 和 dp[i][0] 都已经初始化了，那么其他下标应该初始化多少呢？
其实从递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 可以看出dp[i][j] 是又左上方数值推导出来了，那么 其他下标初始为什么数值都可以，因为都会被覆盖。
- 确定遍历顺序
在如下图中，可以看出，有两个遍历的维度：物品与背包重量
那么问题来了，先遍历 物品还是先遍历背包重量呢？
其实都可以！！ 但是先遍历物品更好理解。
为什么也是可以的呢？
要理解递归的本质和递推的方向。
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 递归公式中可以看出dp[i][j]是靠dp[i-1][j]和dp[i - 1][j - weight[i]]推导出来的。
dp[i-1][j]和dp[i - 1][j - weight[i]] 都在dp[i][j]的左上角方向（包括正上方向），那么先遍历物品，再遍历背包的过程如图所示：
再来看看先遍历背包，再遍历物品呢，如图：
大家可以看出，虽然两个for循环遍历的次序不同，但是dp[i][j]所需要的数据就是左上角，根本不影响dp[i][j]公式的推导！
但先遍历物品再遍历背包这个顺序更好理解。
其实背包问题里，两个for循环的先后循序是非常有讲究的，理解遍历顺序其实比理解推导公式难多了。
- 举例推导dp数组
来看一下对应的dp数组的数值，如图：
最终结果就是dp[2][4]。
建议大家此时自己在纸上推导一遍，看看dp数组里每一个数值是不是这样的。
public static void testWeightBagProblem(int[] weight, int[] value, int bagSize){
int wLen = weight.length, value0 = 0;
//定义dp数组：dp[i][j]表示背包容量为j时，前i个物品能获得的最大价值
int[][] dp = new int[wLen + 1][bagSize + 1];
//初始化：背包容量为0时，能获得的价值都为0
for (int i = 0; i <= wLen; i++){
dp[i][0] = value0;
}
//遍历顺序：先遍历物品，再遍历背包容量
for (int i = 1; i <= wLen; 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 <= wLen; i++){
for (int j = 0; j <= bagSize; j++){
System.out.print(dp[i][j] + " ");
}
System.out.print("\n");
}
}
416. 分割等和子集
给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。
示例 1：
输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。
示例 2：
输入：nums = [1,2,3,5]
输出：false
解释：数组不能分割成两个元素和相等的子集。
只要找到集合里能够出现 sum / 2 的子集总和，就算是可以分割成两个相同元素和子集了
public boolean canPartition(int[] nums) {
int sum=0;
for(int num:nums){
sum+=num;
}
int aim=sum/2;
if(sum%2!=0){
return false;
}
return process2dp(nums,aim);
}
private boolean process(int[] nums,int index,int aim){
if(index==nums.length){
return aim==0;
}
return process(nums,index+1,aim) ||
(aim-nums[index]>=0 && process(nums,index+1,aim-nums[index]));
}
private boolean process2dp(int[] nums,int aim){
// index 0---n aim 0---aim
int n=nums.length;
boolean[][] dp=new boolean[n+1][aim+1];
dp[n][0]=true;
for(int i=n-1;i>=0;i--){
for(int j=0;j<=aim;j++){
dp[i][j]=dp[i+1][j];
if(j-nums[i]>=0){
dp[i][j] = dp[i][j] || dp[i+1][j-nums[i]];
}
}
}
return dp[0][aim];
}
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
示例 3：
输入：stones = [1,2]
输出：1
416. 分割等和子集 相当于是求背包是否正好装满，而本题是求背包最多能装多少。
class Solution {
public int lastStoneWeightII(int[] stones) {
int sum=0;
for(int s:stones){
sum+=s;
}
int target=sum>>1;
int res=process2dp(stones ,target);
return sum-2*res;
}
//151/2. =75.target. 151-2*dp[target] 求背包最多能装多少
// 31 26 21=78*2=156 33+40=73*2=146
//23 11. 11*2=22
//416. 分割等和子集 (opens new window)相当于是求背包是否正好装满，而本题是求背包最多能装多少。
//0--index rest 最多能装多少
private int process(int[] stones,int index,int rest){
if(rest<=0){
return 0;
}
if(index==stones.length){
return 0;
}
int p1= process(stones,index+1,rest);
int p2=Integer.MIN_VALUE;
if(rest-stones[index]>=0){
p2= process(stones,index+1,rest-stones[index])+stones[index];
}
return Math.max(p1,p2);
}
private int process2dp(int[] stones,int rest){
//N 0---N rest 0---rest
int N=stones.length;
int[][] dp=new int[N+1][rest+1];
for(int i=N-1;i>=0;i--){
for(int j=1;j<=rest;j++){//注意这里的大于小于号不要写错了
int p1=dp[i+1][j];
int p2=Integer.MIN_VALUE;
if(j-stones[i]>=0){
p2=dp[i+1][j-stones[i]]+stones[i];
}
dp[i][j]=Math.max(p1,p2);
}
}
return dp[0][rest];
}
}
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
public int findTargetSumWays(int[] nums, int target) {
return process(nums,0,0,target);
}
//可以转化为求和为0 ，a,b,c,d 每个数字都可以下负转化
private int process(int[] nums,int index,int sum,int target){
if(index==nums.length){
return sum==target?1:0;
}
return process(nums,index+1,sum+nums[index],target)+
process(nums,index+1,sum-nums[index],target);
}
