4.01背包问题

 

有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];
    }

  

依然动规五部曲分析一波。

  1. 确定dp数组以及下标的含义

dp[i][j] 表示从下标为[0-i]的物品里任意取,放进容量为j的背包,价值总和最大是多少。

  1. 确定递推公式
  • 不放物品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]);

  1. dp数组如何初始化

如果背包容量j为0的话,即dp[i][0],无论是选取哪些物品,背包价值总和一定为0  

  1. 确定遍历顺序

在如下图中,可以看出,有两个遍历的维度:物品与背包重量

那么问题来了,先遍历 物品还是先遍历背包重量呢?

其实都可以!! 但是先遍历物品更好理解。

  1. 举例推导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");
        }
    }

 

一维dp数组(滚动数组)

  1. 确定dp数组的定义

在一维dp数组中,dp[j]表示:容量为j的背包,所背的物品价值可以最大为dp[j]。

  1. 一维dp数组的递推公式

此时dp[j]有两个选择,

一个是取自己dp[j] 相当于 二维dp数组中的dp[i-1][j],即不放物品i,

一个是取dp[j - weight[i]] + value[i],即放物品i,指定是取最大的,毕竟是求最大价值,

所以递归公式为:

dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

 

  1. 一维dp数组如何初始化

dp[j]表示:容量为j的背包,所背的物品价值可以最大为dp[j],那么dp[0]就应该是0,因为背包容量为0所背的物品的最大价值就是0。

  1. 一维dp数组遍历顺序
 public static void testWeightBagProblem(int[] weight, int[] value, int bagWeight){
        int wLen = weight.length;
        //定义dp数组:dp[j]表示背包容量为j时,能获得的最大价值
        int[] dp = new int[bagWeight + 1];
        //遍历顺序:先遍历物品,再遍历背包容量
        for (int i = 0; i < wLen; i++){
            for (int j = bagWeight; j >= weight[i]; j--){
                dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
            }
        }
        //打印dp数组
        for (int j = 0; j <= bagWeight; j++){
            System.out.print(dp[j] + " ");
        }
    }

  

 这里大家发现和二维dp的写法中,遍历背包的顺序是不一样的!

二维dp遍历的时候,背包容量是从小到大,而一维dp遍历的时候,背包是从大到小。

为什么呢?

倒叙遍历是为了保证物品i只被放入一次!。但如果一旦正序遍历了,那么物品0就会被重复加入多次!

举一个例子:物品0的重量weight[0] = 1,价值value[0] = 15

如果正序遍历

dp[1] = dp[1 - weight[0]] + value[0] = 15

dp[2] = dp[2 - weight[0]] + value[0] = 30

此时dp[2]就已经是30了,意味着物品0,被放入了两次,所以不能正序遍历。

为什么倒叙遍历,就可以保证物品只放入一次呢?

倒叙就是先算dp[2]

dp[2] = dp[2 - weight[0]] + value[0] = 15 (dp数组已经都初始化为0)

dp[1] = dp[1 - weight[0]] + value[0] = 15

所以从后往前循环,每次取得状态不会和之前取得状态重合,这样每种物品就只取一次了。

那么问题又来了,为什么二维dp数组历的时候不用倒叙呢?

因为对于二维dp,dp[i][j]都是通过上一层即dp[i - 1][j]计算而来,本层的dp[i][j]并不会被覆盖!

(如何这里读不懂,大家就要动手试一试了,空想还是不靠谱的,实践出真知!)

再来看看两个嵌套for循环的顺序,代码中是先遍历物品嵌套遍历背包容量,那可不可以先遍历背包容量嵌套遍历物品呢?

不可以!

因为一维dp的写法,背包容量一定是要倒序遍历(原因上面已经讲了),如果遍历背包容量放在上一层,那么每个dp[j]就只会放入一个物品,即:背包里只放入了一个物品。

(这里如果读不懂,就在回想一下dp[j]的定义,或者就把两个for循环顺序颠倒一下试试!)

所以一维dp数组的背包在遍历顺序上和二维其实是有很大差异的!,这一点大家一定要注意。

  1. 举例推导dp数组

一维dp,分别用物品0,物品1,物品2 来遍历背包,最终得到结果如下:

动态规划-背包问题9

   

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. 分割等和子集 相当于是求背包是否正好装满,而本题是求背包最多能装多少。

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

那么相撞之后剩下的最小石头重量就是 (sum - dp[target]) - dp[target]。

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);
        }

  

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        // l-r=target
        // l+r=sum
        // l-(sum-l)=target
        //l=(sum+target)/2
        //can find l in nums
        //0...i  j dp[i][j]
        int sum=0;
        for(int num:nums){
            sum+=num;
        }
        if((sum+target)%2!=0) return 0;
        int size=(sum+target)/2;
        if(size<0) size=-size;
        return process2dp(nums,size);
    }

    public int process2dp(int[] nums,int size){
        int[] dp=new int[size+1];
        dp[0]=1;
        for(int i=0;i<nums.length;i++){
            for(int j=size;j>=nums[i];j--){
                dp[j]+=dp[j-nums[i]];
            }
        }
        return dp[size];
    }

}

  

 

.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 。

示例 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

 

class Solution {
    int size=0;
    public int findMaxForm(String[] strs, int m, int n) {
      //  return process(strs,m,n,0,0,0);
       return process2dp(strs,m,n);
    }
    // 01 001 100. index sum_1<=m sum_0<=n

    private int process(String[] strs,int m,int n,int index,int sum_1,int sum_0){
        if(index==strs.length){
            return 0;
        }

        if(sum_0>m && sum_1>n){
            return 0;
        }

       int p1= process(strs,m,n,index+1,sum_1,sum_0);
       String s= strs[index];
       int sum1=0;
       int sum0=0;
       for(char c:s.toCharArray()){
           if(c=='0'){
               sum0++;
           }
           if(c=='1'){
               sum1++;
           }
         
       }
int p2=Integer.MIN_VALUE;
       if(sum0+sum_0<=m && sum1+sum_1<=n){
 p2= process(strs,m,n,index+1,sum_1+sum1,sum_0+sum0) + 1;
       }
       return Math.max(p1,p2);
    }

    private int process2dp(String[] strs,int m,int n){
        //index 0---strs.length().  sum0. 0---m sum1 0---n
        int N=strs.length;
        int[][][] dp=new int[N+1][m+1][n+1];
        for(int i=N-1;i>=0;i--){
            for(int j=0;j<=m;j++){
                for(int k=0;k<=n;k++){
                    int p1=dp[i+1][j][k];
                     String s= strs[i];
                        int sum1=0;
                        int sum0=0;
                        for(char c:s.toCharArray()){
                            if(c=='0'){
                                sum0++;
                            }
                            if(c=='1'){
                                sum1++;
                            }
                            
                        }
                        int p2=Integer.MIN_VALUE;
                     if(sum0+j<=m && sum1+k<=n){
                         p2= dp[i+1][sum0+j][sum1+k]+1;
                     }

                     dp[i][j][k]=Math.max(p1,p2);
                }
            }
        }

        return dp[0][0][0];
    }
}

 

  

 

 

  

posted @ 2021-10-30 08:55  sherry001  阅读(26)  评论(0编辑  收藏  举报