动态规划01背包

套路:物够豆包（非潮汕人自行划走）

物就是外层遍历物品

豆包就是潮汕话谐音倒包，也就是倒着遍历背包容量

dp[背包容量]=能装进当前背包容量最大的值。

比如重量和金额都是[1，3，5]，背包容量为1，dp[1]是1，dp[2]还是1

dp[3]就可以把三放进去了，dp[4]是4，可以放1和3

诸如此类

然后dp咋推导公式?

dp[重量w] = math.max(

dp[重量w],           不放第i个物品的价值

dp[重量w-weight[i]]+value[i]    放第i个物品，那么上一个dp就是zhonglw-weight[i]

）

上面的口诀还有个够，够就是里层遍历要够到nums[i]

直接上:

 上题。

leetcode  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;
        }
        if(sum%2==1) 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]);
           }
        }
        for (int a:dp) { 
        System.out.println(a) ; }
        return dp[target] == target;//是不是塞满了，满了就对了
    }

这样就转完了。

 

 

leetcode1049

最后一块石头重量

有一堆石头，每块石头的重量都是正整数。

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

如果 x == y，那么两块石头都会被完全粉碎；

如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。

最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。

示例：

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

这道题说实话，我想半天没想明白它是个背包。

后来看了题解，高人说事实上不就是把石头尽可能分成大小差不多的两堆。。。

我感觉智商被碾压。。。

来人，上套路

class Solution {
    public int lastStoneWeightII(int[] stones) {
        int totalWeight = 0;
        for(int stone:stones){
            totalWeight+=stone;
        }
        int target = totalWeight / 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-stones[i]]+stones[i]
               ,dp[j]);
            }
        }
        System.out.println(""+totalWeight+" d "+dp[target]);
        return totalWeight -dp[target] * 2;  //两堆东西减了
    }
}

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

 

解答:说实话，这个我也没看出和背包有啥关系，注意到这里面nums[i]都是正数哈。

那么好玩的来了，你不是只能加减吗

那么我把数组分为两堆，比如nums = [1,1,1,1,1], target = 3
那么变成

   【1，1，1，1】    【1】

这两个背包，前面一个背包是+，后面一个背包是-，不就可以了吗

假设小一点的背包大小是w，那么w+(w+target)=sum，推出w是sum减去target然后除以2

然后dp公式是什么?

我们先上套路

      int w = (sum -target) / 2;
       int[] dp = new int[w+1];
       dp[0]=1;
        for (int i=0; i<nums.length ; i++) { 
           for (int j=w; j>=nums[i] ; j--) {  
               这里是dp
           }
         }

一看，嗯。里面肯定是dp[j]=?了

那么思考dp[j]和nums[i]的关系，其实dp[j]和dp[j-nums[i]]的方式数量好像是一样的

只要累加起来就可以了，那么dp[j]+=dp[j-nums[i]

就可以了，这还没完

如果不初始化dp数组待会打印出来全是0！

初始化哪些呢?大于1的可以吗?那肯定不行，谁知道能不能填满呢，考虑0吧。

我们想想[1]这个，只有一个的情况下，dp[1]和dp[1-1]是一样的(上文dp[j]和dp[j-nums[i]]的方式数量好像是一样的)

dp[0]咋初始化?那就等于1呗。

ok题目到现在完全完成。

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

474一和零

给你一个二进制字符串数组 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 。

解答:想象一下有两种背包，一个装1，设置为j，一个装0，设置为z

public int findMaxForm(String[] strs, int m, int n) {
        int[][] dp = new int[m+1][n+1];
        dp[0][0] = 0;
        for(int i =0;i<strs.length;i++){//物
            int zeroNum = 0,oneNum = 0;
            for(char c : strs[i].toCharArray()){
                if(c=='0'){
                    zeroNum++;
                }else{
                    oneNum++;
                }
            }
           
            for (int j=m; j>=zeroNum ; j--) { //个倒包1
                for (int z=n; z>=oneNum; z--) {//个倒包2，这里要算出0和1的个数就是了
                  dp[j][z] = Math.max(dp[j][z],
                      dp[j-zeroNum][z-oneNum] + 1 

//考虑一下只有一个元素，这里要+1，那么上面dp[0][0]就只能是0
                  );
                }
             }
        }
        return dp[m][n];