最后一个块石头的重量||

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

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

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

思路：可以将所有的石头尽量分成重量近似相等的两堆，这样碰撞之后剩下的石头的重量就回事最小的，本题可以抽象成0-1背包：物品就是所有的石头，背包的容量就是sum/2

二维dp数组

dp[i][j]的含义：对于前i个物品，容量为j的背包，可以装的最大价值为dp[i][j]
递推公式：dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-stones[i-1]]+stones[i-1]
dp数组的初始化：dp[i][0] = 0，dp[0][j] = 0
遍历顺序：先遍历物品（从小大到），后遍历背包（从小到大）
打印dp数组：debug使用

class Solution {
    public int lastStoneWeightII(int[] stones) {
        int sum = 0;
        for(int i : stones){
            sum += i;
        }
        // 物品
        int N = stones.length;
        // 背包 
        int target = sum / 2;
        int[][] dp = new int[N+1][target+1];
        for(int i = 1;i<=N;i++){
            for(int j = 1;j<=target;j++){
                if(j < stones[i-1]){
                    dp[i][j] = dp[i-1][j];
                }else{
                    dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-stones[i-1]]+stones[i-1]);
                }
            }
        }
        // dp[N][target]是实际上最后背包的最大价值，不一定等于target，所有下面计算的时候需要使用dp[N][target]而不是target
        // 为什么不需要取绝对值，因为target的取值是向下取整的，所有sum-target 一定大于 target
        return sum - dp[N][target] - dp[N][target];
    }
}

一维dp数组

dp[j]的含义：当背包容量为j的时候，能够装的最大价值为dp[j]
递推公式：dp[j] = Math.max(dp[j],dp[j-stones[i]]+stones[i])
dp数组的初始化：dp[0] = 0
遍历顺序：先遍历物品（从小到大），在遍历背包（从大到小）
打印dp数组

class Solution {
    public int lastStoneWeightII(int[] stones) {
       int sum = 0;
       for(int i : stones){
           sum += i;
       }
       int target = sum / 2;
       int[] dp = new int[target + 1];
       dp[0] = 0;
       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];
    }
}

目标和

题目：给你一个整数数组 nums 和一个整数 target 。

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

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

二维数组

思路：我们假设将nums数组分成两个集合，一个集合A全是’+‘，集合B全是’-'，那么就有如下的公式
目标和
然后我们就需要求sum(A)的组合有多少就可以了

dp[i][j]的含义：对于前i个数，选择任意的数的和为j，总共有dp[i][j]种方式
递推公式：dp[i][j] = dp[i-1][j] + dp[i-1][j-nums[i]]，这里需要求总共有多少种方式，所以需要加上以前的
dp数组的初始化：dp[0][0] = 1，因为对于0个数字，表达式的和为0，总共有1一种方式；不能初始化为0，因为根据递推公式来看，后面的值依赖前面的值，如果初始化为0的话，那么后面的所有的值都会是0
遍历顺序：先遍历物品（从小到大），后遍历背包（从小到大）
打印dp数组

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int n = nums.length;
        int sum = 0;
        for(int i : nums){
            sum+=i;
        }
        if(target < 0 && (sum + target) < 0) return 0;
        if((sum + target) % 2 != 0) return 0;
        int w = (sum + target) / 2;
        int[][] dp = new int[n+1][w+1];
        dp[0][0] = 1;
        for(int i = 1;i<=n;i++){
            for(int j = 0;j<=w;j++){
                if(j < nums[i-1]){
                    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][w];
    }
}

一维数组

dp[j]的含义：填满容量为j的背包的方法有dp[j]种
递推公式：dp[j] += dp[j-nums[i]]
dp数组初始化：dp[0] = 1
遍历顺序：先遍历物品（从小到大），后遍历背包（从大到小）
打印dp数组

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int n = nums.length;
        int sum = 0;
        for(int i : nums){
            sum+=i;
        }
        // 如果和为奇数，就不能平分，就不可能存在表达式加起来等于target
        if((sum + target) % 2 == 1) return 0;
        // 数组的和小于target的绝对值的时候也不会有方案
        if(sum < Math.abs(target)) return 0;
        int w = (sum + target) / 2;
        int[] dp = new int[w+1];
        dp[0] = 1;
        for(int i = 0;i<n;i++){
            for(int j = w;j>=nums[i];j--){
                // 这里为什么没有+nums[i]了，因为我们求的是方法数，如果选择当前物品i，那么总共的方案就取决于j-nums[i]的方案有多少，而不是背包的价值，只有在求价值的时候才需要加上
                dp[j] += dp[j-nums[i]];
            }
        }
        return dp[w];
    }
}

一和零

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

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

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

思路：本题同样可以抽象成0-1背包的问题，物品就是strs数组中的元素，背包容量就是m个0和n个1，只是本题的背包容量存在两个维度

dp[i][j]的含义：有i个0和j个1的最大长度的子集（背包）的长度是dp[i][j]
递推公式：dp[i][j] = Math.max(dp[i][j],dp[i-zeroNum][j-oneNum]+1)
- 为什么这里是+1，而不是之前的+nums[i]，因为本题求的个数，而不是最大价值，所有固定+1
dp数组初始化：dp[0][0] = 0
遍历顺序：先遍历物品（从小到大），后遍历背包（从大到小）
打印dp数组

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][] dp = new int[m+1][n+1];
        dp[0][0] = 0;

        // 填充dp数组
        for(String str : strs){// 遍历物品
            // 统计每个字符串中的0 和 1 分别有多少个
            int zeroNum = 0,oneNum = 0;
            for(int i = 0;i<str.length();i++){
                if(str.charAt(i) == '0'){
                    zeroNum++;
                }else{
                    oneNum++;
                }
            }

            // 遍历背包
            for(int i = m;i>=zeroNum;i--){
                for(int j = n;j>=oneNum;j--){
                    // 这里+1，就相当于+nums[i]，只是这里要求的不是价值，而是个数，所有固定+1
                    dp[i][j] = Math.max(dp[i][j],dp[i-zeroNum][j-oneNum]+1);
                }
            }
        }
        return dp[m][n];
    }
}