0-1背包题目练习

0-1背包题目练习

动态规划有一些小例子跟背包没什么关系的简单题，斐波那契、爬楼梯等，可以熟悉一下动态规划做题五部曲，这里只讲和0-1背包有关的相关问题。

416. 分割等和子集

给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。

这个题跟0-1背包有什么关系呢？这就涉及到了向0-1背包问题转换的过程。

分析题目，分割后的两个子集元素和相等，也就是说S1=S2，又因为S1+S2 = SUM 所以 S1 = SUM /2 那么就会发现，我们只要能找到一个子集和为总和的一半，那么剩下的元素的和也就和这个子集相等了，这不就是0-1背包问题么，在一堆物品（数组的值）中，选取能够装满背包容量为SUM/2 的物品。

明确一下 背包容量 = SUM/2 物品价值 = nums[i] 物品质量 = nums[i]，再说一点，如果SUM本身除2除不尽，那就说明根本不能分解成两个相等的子集。

话不多说，直接上代码：

class Solution {
    public boolean canPartition(int[] nums) {
		if(nums.length ==0 || nums.length ==null) return false;
        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<nums.length;i++){
            for(int j =target;j>=nums[i];j--){
                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。

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

分析题目：就是要我们尽量将石头平均分成两堆，每一堆石头的重量越接近SUM/2，那么最后剩下来的石头重量就会越小。

也就转换成了，在一堆物品（石头）中，尽可能的填满容量为SUM/2的背包，并且价值总和（质量）要最大。

dp[j] 的含义就是，考虑前i个石头， 当背包容量为j时，能得到的最大价值（也就是质量）；

上代码：

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

这个题总的来说跟上一题有些相似，只不过这个题近似SUM/2就可以了。

494. 目标和

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

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

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

输入：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

这个题首先看过去想到的应该是回溯法，每选择一个数就有两种可能性，加或者减，直到遍历完最后一个数，如果结果为target那么就次数+1，然后回溯遍历所有情况即可。

这里贴上回溯的代码：

class Solution {
    int count = 0;
    public int findTargetSumWays(int[] nums, int target) {
			backtrack(nums,target,0,0);
        	return count; 
    }
    public void backtrack(int[] nums,int target,int index,int sum){
        if(index == nums.length){
            if(sum == target){
                count++;
            }
            return;
        }
        //两种情况回溯
        backtrack(nums,target,index+1,sum + nums[index]);
        backtrack(nums,target,index+1,sum - nums[index]);
    }
}

但是这个题还能用动态规划求解，也就是转成0-1背包问题。

分析题目意思，一堆数有正有负，positiveNum和nativeNum（值为正，需要添加负号的数） 他们的和为SUM

即p + n = SUM 即 p = SUM - n， 又因为题目所需要的target = p - n 所以 target = SUM-2n 所以 n =( SUM - target ) /2

那么意思就是只要在这一堆数中，找到和为n的数值有多少种组合即可。

dp[j] 的含义就是，找到和为j 的数字组合最大有多少种。

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        int diff = sum - target;
        if (diff < 0 || diff % 2 != 0) {
            return 0;
        }
        int neg = diff / 2;
        int[] dp = new int[neg + 1];
        dp[0] = 1;
        for (int num : nums) {
            for (int j = neg; j >= num; j--) {
                dp[j] += dp[j - num];
            }
        }
        return dp[neg];
    }
}

474. 一和零

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

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

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

输入：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 。

这个题和之前的背包问题稍微有一些不同，这里有两个背包容量维度，m和n，相当于我们找的物品重量要同时满足这两个条件。

直接上代码：

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][] dp = new int[m+1][n+1];
        int zeroNum;
        int oneNum ;
        for(String str : strs){
            zeroNum =0;
            oneNum = 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];

    }
}

遍历每个字符串，并且保存其中0和1的数量，之前的背包问题每次遍历一个物品更新的是一行数据，而这里更新的是一张表的数据，也可以用三维数组来表示。

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int length = strs.length;
        int[][][] dp = new int[length + 1][m + 1][n + 1];
        for (int i = 1; i <= length; i++) {
            int[] zerosOnes = getZerosOnes(strs[i - 1]);
            int zeros = zerosOnes[0], ones = zerosOnes[1];
            for (int j = 0; j <= m; j++) {
                for (int k = 0; k <= n; k++) {
                    dp[i][j][k] = dp[i - 1][j][k];
                    if (j >= zeros && k >= ones) {
                        dp[i][j][k] = Math.max(dp[i][j][k], dp[i - 1][j - zeros][k - ones] + 1);
                    }
                }
            }
        }
        return dp[length][m][n];
    }

    public int[] getZerosOnes(String str) {
        int[] zerosOnes = new int[2];
        int length = str.length();
        for (int i = 0; i < length; i++) {
            zerosOnes[str.charAt(i) - '0']++;
        }
        return zerosOnes;
    }
}

下面这个题和0-1背包关系不大，是树形dp的入门题目，也可以看一下。

337. 打家劫舍 III

小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。

除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果 两个直接相连的房子在同一天晚上被打劫 ，房屋将自动报警。

给定二叉树的 root 。返回 在不触动警报的情况下 ，小偷能够盗取的最高金额 。

class Solution {   
    public int rob(TreeNode root) {
       int[] res = robAction(root);
       return Math.max(res[0],res[1]);
    }
    public int[] robAction(TreeNode root){
        int[] res = new int[2];
        if(root == null) return res;
        int[] left = robAction(root.left);
        int[] right = robAction(root.right);
        //不偷当前节点,那么就考虑左节点最大的和右节点最大价值之和
        res[0] = Math.max(left[0],left[1]) + Math.max(right[0],right[1]);
        //偷当前节点，那左右节点就只能算不偷的最大价值。
        res[1] = root.val + left[0] + right[0];
        return res;
    }
}