最后一个石头重量 &&目标和 && 一和零 DAY23

14.最后一块石头的重量

有一堆石头，用整数数组 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]，这就是最优值。

提示：

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

思路

本题其实就是尽量让石头分成重量相同的两堆，相撞之后剩下的石头最小，这样就化解成01背包问题了。

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

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

1…dp数组以及下标的含义

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

回忆一下01背包中，dp[j]的含义，容量为j的背包，最多可以装的价值为 dp[j]。

相对于 01背包，本题中，石头的重量是 stones[i]，石头的价值也是 stones[i] ，就有 “最多可以装的价值为 dp[j]” == “最多可以背的重量为dp[j]”

2.递推公式

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

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

3.dp数组初始化

因为重量都不会是负数，所以dp[j]都初始化为0；

提示中给出1 <= stones.length <= 30，1 <= stones[i] <= 1000，所以最大重量就是30 * 1000 ，而我们要求的target其实只是最大重量的一半，所以dp数组开到15000大小就可以了。

4.遍历顺序

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

for (int i = 0; i < stones.size(); i++) { // 遍历物品
    for (int j = target; j >= stones[i]; j--) { // 倒叙遍历背包
        dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
    }
}

5.举例推导dp数组

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

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

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

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

class Solution {
    public int lastStoneWeightII(int[] stones) {
        int sum = 0,target = 0;
        for(int i = 0;i < stones.length;i++){
            sum += stones[i];
        }
        target = sum/2;
        //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]);
            }
            for(int z = 0;z < dp.length; z++){
                System.out.print(dp[z] + " ");
            }
            System.out.println("");
        }
        //dp数组
        0 0 2 2 2 2 2 2 2 2 2 2 
        0 0 2 2 2 2 2 7 7 9 9 9 
        0 0 2 2 4 4 6 7 7 9 9 11 
        0 1 2 3 4 5 6 7 8 9 10 11 
        0 1 2 3 4 5 6 7 8 9 10 11 
        0 1 2 3 4 5 6 7 8 9 10 11 
        return sum - dp[target] - dp[target];
    }
}

总结

本题和 “分割等和子集”类同，只是最后对dp[target]的处理方式不同。前者相当于是求背包是否正好装满，而本题是求背包最多能装多少？。

16.目标和

给你一个非负整数数组 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

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

思路

本题要如何使表达式结果为target？

既然为target，那么就一定有 left组合 - right组合 = target。其中left代表加法集合，right代表减法集合（都是正数）。

left + right = sum，而sum是固定的。right = sum - left

于是有： left - (sum - left) = target 推导出 left = (target + sum)/2 。

target是固定的，sum是固定的，left就可以求出来。

**此时问题就是在集合nums中找出和为left的组合。**即找出哪些元素进行组合，和为left。

回溯法

动态规划-01背包

我们要求的是 x - (sum - x) = target，–> x = (target + sum)/2;

此时问题就转化为，装满容量为 x 的背包，有几种方法。这里的x，就是bagSize，也就是我们后面要求的背包容量。

为什么 x 代表 容量 而不是价值呢？

本题中的容量与价值应该是同等的数值，dp[j]代表价值为 j 时有多少种组合方法。等价于 装满容量为 j 时有多少种方法。

为什么是01背包呢？

因为每个物品（题目中的1）只用一次！

这次和之前遇到的背包问题不一样了，之前都是求容量为j的背包，最多能装多少。本题则是装满有几种方法。其实这就是一个组合问题了。

x 不能整除怎么办？

不能整除说明没有组合的方案。直接return 0 .

1.dp数组的定义

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

dp[i][j]：使用 下标为[0, i]的nums[i]能够凑满 j（包括j）这么大容量的包，有dp[i][j]种方法。

2.递推公式

有哪些来源可以推出dp[j]呢？

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

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

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

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

dp[5] = dp[1] + dp[2] + dp[3] + dp[4] + dp[0]
dp[j] += dp[j - nums[i]]

3.初始化

如果数组[0] ，target = 0，那么 bagSize = (target + sum) / 2 = 0。 dp[0]也应该是1， 也就是说给数组里的元素 0 前面无论放加法还是减法，都是 1 种方法。

应该初始化 dp[0] 为 1；如果dp[0]是0的话，递推结果将都是0。

dp[j]其他下标对应的数值应该初始化为0，从递推公式也可以看出，dp[j]要保证是0的初始值，才能正确的由dp[j - nums[i]]推导出来。

4.遍历顺序

一维dp数组，物品nums为外循环，target容量为倒叙内循环。

5.举例dp数组

输入：nums: [1, 1, 1, 1, 1], S: 3

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

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for(int i = 0; i < nums.length;i++){
            sum += nums[i];
        }
        if((target + sum)%2 != 0) return 0;//如果(target+sum)除以2的余数不为0，是没有方案的
        if(Math.abs(target) > sum) return 0;//如果target的绝对值大于sum，那么是没有方案的
        int left = (target + sum)/2;
        //dp数组
        int[] dp = new int[left + 1];
        //初始化
        dp[0] = 1;
        //遍历
        for(int i = 0; i < nums.length;i++){//物品
            for(int j = left; j >= nums[i];j-- ){//背包
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[left];
    }
}

总结

1.本道题和“分割等和子集【能不能装满背包？】”、“最后一块石头的重量【背包最大能装多少？】”类似，都是需要将一个数组分为两个子集。本题是分为一个加法集合与一个减法集合。

2.本题转化为：装满容量为 left 的背包有多少种方法。$dp[j]+=dp[j-nums[i]];$

17.一和零？

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的长度，该子集中 最多 有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。

示例 1：

输入：strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3
输出：4
解释：最多有 5 个 0 和 3 个 1 的最大子集是 {"10","0001","1","0"} ，因此答案是 4 。
其他满足题意但较小的子集包括 {"0001","1"} 和 {"10","1","0"} 。{"111001"} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。

示例 2：

输入：strs = ["10", "0", "1"], m = 1, n = 1
输出：2
解释：最大的子集是 {"0", "1"} ，所以答案是 2 。

提示：

• 1 <= strs.length <= 600
• 1 <= strs[i].length <= 100
• strs[i] 仅由 '0' 和 '1' 组成
• 1 <= m, n <= 100

思路

判断本题属于哪种背包问题，很多人认为是多重背包。多重背包是每个物品，数量不同的情况。本题中strs 数组里的元素就是物品，每个物品都是一个！而m 和 n相当于是一个背包，两个维度的背包。

理解成多重背包的同学主要是把m和n混淆为物品了，感觉这是不同数量的物品，所以以为是多重背包。

但本题其实是01背包问题！

只不过这个背包有两个维度，一个是m 一个是n，而不同长度的字符串就是不同大小的待装物品。

物品就是strs里的字符串，背包容量就是题目描述中的m和n。

1.dp数组（dp table）以及下标的含义

dp[i][j]：最多有i个0和j个1的strs的最大子集的大小为dp[i][j]。

2.递推公式

dp[i][j]可以由前一个strs里的字符串推导出来，strs里的字符串有zeroNum个0，oneNum个1。

字符串的zeroNum和oneNum相当于物品的重量（weight[i]），字符串本身的个数相当于物品的价值（value[i]）。

dp[i][j] 就可以是 dp[i - zeroNum][j - oneNum] + 1。

背包的最大容量为m个0，n个1；当物品装进背包时，最大子集长度+1，也就是价值+1；

在遍历的过程中，取dp[i][j]的最大值。

所以递推公式：dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);

3.初始化

因为物品价值不会是负数，初始为0，保证递推的时候dp[i][j]不会被初始值覆盖。

4.遍历顺序

外层for循环遍历物品，内层for循环遍历背包容量且从后向前遍历！

遍历背包容量m,n的两层for循环先后循序有没有什么讲究？

没讲究，都是物品重量的一个维度，先遍历哪个都行！

for (string str : strs) { // 遍历物品
    int oneNum = 0, zeroNum = 0;
    for (char c : str) {
        if (c == '0') zeroNum++;
        else oneNum++;
    }
    for (int i = m; i >= zeroNum; i--) { // 遍历背包容量且从后向前遍历！
        for (int j = n; j >= oneNum; j--) {
            dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
        }
    }
}

5.举例推导dp数组

以输入：[“10”,“0001”,“111001”,“1”,“0”]，m = 3，n = 3为例

最后dp数组的状态如下所示：

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        dp[i][j]表示i个0和j个1时的最大子集
        int[][] dp = new int[m+1][n+1];
        int  oneNum , zeroNum ;
        for(String str : strs){//遍历物品
            oneNum = 0;
            zeroNum = 0;
            for(char c : str.toCharArray()){
                if(c == '0'){
                    zeroNum++;
                }else{
                    oneNum++;
                }
            }
            //倒叙遍历两个维度的背包容量
            for(int i = m; i >= zeroNum; i--){
                for(int j = n;j >= oneNum; j--){
                    dp[i][j] = Math.max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1); 
                }
            }
        }
        return dp[m][n];
    }
}

总结

递推公式都没搞明白，看题解都不理解。

1.本题是两个维度的背包容量！物品就是strs里的字符串，背包容量就是题目描述中的m和n

2.dp[i][j]表示 i个0和 j个1时的最大子集。

纯01背包：求 给定背包容量 装满背包 的最大价值是多少。

分割等和子集：求 给定背包容量，能不能装满这个背包。

最后一块石头的重量：求 给定背包容量，尽可能装，最多能装多少。

目标和：求 给定背包容量，装满背包有多少种方法。

一和零：求 给定背包容量，装满背包最多有多少个物品。