二维01背包 && 背包滚动数组 && 分割等和子集 DAY22

喝哈喝哈

于 2024-07-29 21:47:46 发布

阅读量664

点赞数 9

分类专栏：算法学习笔记文章标签：算法动态规划

本文链接：https://blog.csdn.net/qq_42734601/article/details/140782060

版权

算法学习笔记专栏收录该内容

24 篇文章 0 订阅

订阅专栏

11.背包理论基础

有n件物品和一个最多能背重量为w 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

背包问题有多种背包方式，常见的有：01背包、完全背包、多重背包、分组背包和混合背包等等。即一个商品如果可以重复多次放入是完全背包，而只能放入一次是01背包。

每一件物品其实只有两个状态，取或者不取，所以可以使用回溯法搜索出所有的情况，那么时间复杂度就是 $o(2^n)$ ，这里的n表示物品数量。

暴力的解法是指数级别的时间复杂度。进而才需要动态规划的解法来进行优化！

leetcode上没有纯01背包的问题，都是01背包应用方面的题目，也就是需要转化为01背包问题。

对于面试的话，其实掌握01背包，和完全背包，就够用了，最多可以再来一个多重背包。

二维dp数组01背包

1.dp数组及下标的含义

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

2.递推公式

有两个方向推出来dp[i][j]：

1.不放物品 i ：此时就是dp[i-1][j] 。(其实就是当物品 i 的重量大于背包 j 的重量时，物品 i 无法放进背包中，所以背包内的价值依然和前面相同。)

2.放物品 i：容得下weight[i]的容量，但还没有放 i 时的价值为dp[i - 1][j - weight[i]] ，这时容量为j-weight[i], 在前一次的价值上 + value[i]；所以放物品 i 的价值为：dp[i-1][j-weight[i]]+value[i] 。

所以递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]).

3.初始化

(1)如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为0。
(2) i 是由 i-1 推导出来，那么i 为0的时候就一定要初始化。d[0][j]当 j < weight[0]的时候，dp[0][j] 应该是 0;当j >= weight[0]时，dp[0][j] 应该是value[0]。

(3) 二维数组的其他位置默认初始化为0；实际上初始为任意值都行，因为遍历时都会被覆盖掉。

for (int j = 0 ; j < weight[0]; j++) {  // 当然这一步，如果把dp数组预先初始化为0了，这一步就可以省略，但很多同学应该没有想清楚这一点。
    dp[0][j] = 0;
}
// 正序遍历
for (int j = weight[0]; j <= bagweight; j++) {
    dp[0][j] = value[0];
}

此时dp数组初始化情况：

4.确定遍历顺序

可以看出，有两个遍历的维度：物品与背包重量。

先遍历物品还是先遍历背包重量呢？其实都可以！！但是先遍历物品更好理解。

// weight数组的大小 就是物品个数
for(int i = 1; i < weight.size(); i++) { // 遍历物品   从i=1开始后，i=0已经初始化了  行遍历
    for(int j = 0; j <= bagweight; j++) { // 遍历背包容量
        if (j < weight[i]) dp[i][j] = dp[i - 1][j];
        else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
    }
}
//为什么从j=0开始呢，j=0不也已经有值了嘛？
// weight数组的大小 就是物品个数
for(int j = 0; j <= bagweight; j++) { // 遍历背包容量  列遍历
    for(int i = 1; i < weight.size(); i++) { // 遍历物品
        if (j < weight[i]) dp[i][j] = dp[i - 1][j];
        else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
    }
}

练习

题目描述

小明是一位科学家，他需要参加一场重要的国际科学大会，以展示自己的最新研究成果。他需要带一些研究材料，但是他的行李箱空间有限。这些研究材料包括实验设备、文献资料和实验样本等等，它们各自占据不同的空间，并且具有不同的价值。

小明的行李空间为 N，问小明应该如何抉择，才能携带最大价值的研究材料，每种研究材料只能选择一次，并且只有选与不选两种选择，不能进行切割。

输入描述

第一行包含两个正整数，第一个整数 M 代表研究材料的种类，第二个正整数 N，代表小明的行李空间。

第二行包含 M 个正整数，代表每种研究材料的所占空间。

第三行包含 M 个正整数，代表每种研究材料的价值。

输出描述

输出一个整数，代表小明能够携带的研究材料的最大价值。

输入示例

6 1
2 2 3 1 5 2
2 3 1 5 4 3

输出示例

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int M = sc.nextInt();//种类
        int N = sc.nextInt();//容量
        
        System.out.println("M = "+M + " N = "+N);
        
        int[] weights = new int[M];//重量
        int[] values = new int[M];//价值
        
        for(int i = 0; i < M;i++){
            weights[i] = sc.nextInt();
            // System.out.print("weights[" + i + "] "+weights[i] + " ");
        }
        // System.out.println(" ");
        for(int i = 0; i < M;i++){
            values[i] = sc.nextInt();
            // System.out.print("values[" + i + "] "+values[i] + " ");
        }
        
        int[][] dp = new int[M][N + 1];//dp数组
        
        //初始化
        for(int j = weights[0]; j <= N;j++ ){//为什么是从 weights[0]开始？
            dp[0][j] = values[0];
        }
        /*
        * 其实是模仿背包重量从 0 开始，背包容量 j 为 0 的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为 0。
        * 可选物品也可以从无开始，也就是没有物品可选，即dp[0][j]，这样无论背包容量为多少，背包价值总和一定为 0。
        */
        for(int i = 1;i < M;i++){//先物品
            for(int j = 0;j <= N;j++){//再背包
                if(j < weights[i]){
                    /**
                     * 当前背包的容量都没有当前物品i大的时候，是不放物品i的
                     * 那么前i-1个物品能放下的最大价值就是当前情况的最大价值
                     */
                    dp[i][j] = dp[i-1][j];
                }else{
                    /**
                     * 当前背包的容量可以放下物品i
                     * 那么此时分两种情况：
                     *    1、不放物品i
                     *    2、放物品i
                     * 比较这两种情况下，哪种背包中物品的最大价值最大
                     */
                    dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-weights[i]] + values[i]);
                }
            }
        }
        System.out.println(dp[M-1][N]);//5
        
        // 打印dp数组
        for (int i = 0; i < M; i++) {
            for (int j = 0; j <= N; j++) {
                System.out.print(dp[i][j] + "\t");
            }
            System.out.println("\n");
        }
        /*
        0	0	

        0	0	
        
        0	0	
        
        0	5	
        
        0	5	
        
        0	5	
        */
    }   
}

总结

不理解dp数组中容量1 2 3 4这样的含义。不应该是背包的固定容量与物品的质量进行比较嘛？应该是背包容量从0开始，慢慢变大，对应每个不同容量的情况取得最大价值，直到容量遍历到题目中的容量为止。

本质上还是由先前状态推出当前状态：背包空间为N ，为了得到最优解，先计算计算当背包空间为0 1 2 3 4…时的最优解，递推出背包空间为N时候的最优解。每个物品只有取与不取两种状态，所以叫01背包问题。

12.01背包滚动数组

在使用二维数组的时候，递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

其实可以发现如果把dp[i - 1]那一层拷贝到dp[i]上，表达式完全可以是：dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]);

与其把dp[i - 1]这一层拷贝到dp[i]上，不如只用一个一维数组了，只用dp[j]（一维数组，也可以理解是一个滚动数组）。

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

1.确定dp数组的定义

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

//定义dp数组：dp[j]表示背包容量为j时，能获得的最大价值
int[] dp = new int[bagWeight + 1];

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

dp[j]可以通过dp[j - weight[i]]推导出来: dp[j - weight[i]]表示容量为j - weight[i]的背包所背的最大价值.

dp[j - weight[i]] + value[i] 表示容量为 j - 物品i重量 的背包加上物品i的价值等价于容量为 j 的背包，放入物品 i 了之后的价值即：dp[j]。

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

1.取自己dp[j] 。相当于二维dp数组中的dp[i-1][j]，即不放物品 i。一维dp数组就是拷贝 i-1 层的数据重新计算后覆盖旧值。

2.取dp[j - weight[i]] + value[i]，即放物品 i

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

3.初始化

关于初始化，一定要和dp数组的定义吻合，否则到递推公式的时候就会越来越乱。

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

那么dp数组除了下标0的位置，初始为0，其他下标应该初始化多少呢？

dp数组在推导的时候一定是取价值最大的数，如果题目给的价值都是正整数那么非0下标都初始化为0

假设物品价值都是大于0的，所以dp数组初始化的时候，都初始为0就可以了。

4.一维dp数组遍历顺序

for(int i = 0; i < weight.size(); i++) { // 遍历物品
    for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量，依次从大到小遍历。
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);//dp[1] dp[2]..都不知道，怎么求dp[j]?
    }
}

二维dp遍历的时候，背包容量是从小到大，而一维dp遍历的时候，背包是从大到小。倒序遍历是为了保证物品i只被放入一次！。但如果一旦正序遍历了，那么物品0就会被重复加入多次！

//如果正序遍历
dp[1] = dp[1 - weight[0]] + value[0] =  dp[0] + value[0] = 0 + 15 = 15;

dp[2] = dp[2 - weight[0]] + value[0] =  dp[1] + value[0] = 15 + 15 = 30;//物品0价值15，但是放了两次
//如果倒序遍历
dp[2] = dp[2 - weight[0]] + value[0] = dp[1] + value[0] = 0 + 15 = 15;//容量为2时，也只放了一个物品。
dp[1] = dp[1 - weight[0]] + value[0] = dp[0] + value[0] = 0 + 15 = 15;

**那么问题又来了，为什么二维dp数组遍历的时候不用倒序呢？**因为对于二维dp，dp[i][j]都是通过上一层即dp[i - 1][j]计算而来，本层的dp[i][j]并不会被覆盖！

倒序遍历的原因是，本质上还是一个对二维数组的遍历，并且右下角的值依赖上一层左上角的值，因此需要保证左边的值仍然是上一层的，从右向左覆盖。

那可不可以先遍历背包容量嵌套遍历物品呢？

不可以！因为一维dp的写法，背包容量一定是要倒序遍历。如果遍历背包容量放在上一层，那么每个dp[j]就只会放入一个物品，即：背包里只放入了一个物品。

 public class Main{
     
     public static void main(String[] args) {
            int[] weight = {1, 3, 4};
            int[] value = {15, 20, 30};
            int bagWight = 4;
            testWeightBagProblem(weight, value, bagWight);
        }
    
    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]);
        //     }
        0 15 15 15 15 
        0 15 15 20 35 
        0 15 15 20 35 
        // }
        //测试先倒叙遍历背包，再遍历物品？
        for (int j = bagWeight; j >= 0; j--){//遍历背包
            for (int i = 0; i < wLen; i++){//遍历物品
                if(j >= weight[i]){
                    dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);//每次遍历， dp[j]的值都是与最后一个物品进行比较取最大值。即：背包里只放入了一个物品。
                }
            }
            //打印dp数组
            for (int z = 0; z <= bagWeight; z++){
                System.out.print(dp[z] + " ");
            }
            System.out.println("");
        }
        0 0 0 0 30 //dp[4]取值依次为：i=0时：15，i=1时：20,i=2时:30
        0 0 0 20 30 
        0 0 15 20 30 
        0 15 15 20 30 
        0 15 15 20 30 
       //先遍历物品，测试正序遍历背包 
       for (int i = 0; i < wLen; i++){
            for (int j = 0; j <= bagWeight; j++){
                if(j >= weight[i]){
                    dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
                }
            }
            //打印dp数组
            for (int z = 0; z <= bagWeight; z++){
                System.out.print(dp[z] + " ");
            }
            System.out.println("");
        }
        0 15 30 45 60 //背包容量为2时，物品1被放入了2次。
        0 15 30 45 60 
        0 15 30 45 60 
    }
 }

5.举例推导dp数组

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

6 1//种类，容量
2 2 3 1 5 2//质量
2 3 1 5 4 3//价值
import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int M = sc.nextInt();//种类
        int N = sc.nextInt();//容量
        
        
        int[] weights = new int[M];//重量
        int[] values = new int[M];//价值
        
        for(int i = 0; i < M;i++){
            weights[i] = sc.nextInt();
        }
        for(int i = 0; i < M;i++){
            values[i] = sc.nextInt();
        }
        
        // int[][] dp = new int[M][N + 1];//dp数组
        // //初始化
        // for(int j = weights[0]; j <= N;j++ ){
        //     dp[0][j] = values[0];
        // }
        
        // for(int i = 1;i < M;i++){//先物品
        //     for(int j = 0;j <= N;j++){//再背包
        //         if(j < weights[i]){
        //             dp[i][j] = dp[i-1][j];
        //         }else{
        //             dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-weights[i]] + values[i]);
        //         }
        //     }
        // }
        
        //滚动数组：dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。
        int[] dp = new int[N+1];
        //初始化
        dp[0] = 0;
        //遍历
        for(int i = 0;i < M;i++){//遍历物品
            for(int j = N; j >= weights[i]; j--){//遍历背包，滚动数组以右向左遍历
                dp[j] = Math.max(dp[j],dp[j-weights[i]] + values[i]);
            }
        }
        
        System.out.println(dp[N]);//5
        // 打印dp数组
        for (int i = 0; i <= N; i++) {
                System.out.print(dp[i] + "\t");//0 5 
        }
        /*
        0	0	

        0	0	
        
        0	0	
        
        0	5	
        
        0	5	
        
        0	5	
        */
    }
}

总结

1.滚动数组方法对遍历顺序有要求：只能先遍历物品，再遍历背包；且遍历背包容量时为倒叙；

2.滚动数组的值代表上一状态的最优解，来源于左上方、上方两种情况。不放物品 i 就是上方，放物品 i 就是依据左上方的状态。

为什么前几道题的滚动数组不是从右向左遍历？因为本道题的正序遍历会重复添加物品，而前面的题不会出现这种问题。

3.能不能先遍历背包再遍历物品？不能，因为背包倒叙遍历，遍历物品时每次都只能放一个物品。

4.为什么二维dp数组时不用倒叙？因为dp[i][j]由上一层dp[i-1][j]计算得来，本层的dp[i][j]并不会被覆盖！

13.分割等和子集

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

示例 1：

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

示例 2：

输入：nums = [1,2,3,5]
输出：false
解释：数组不能分割成两个元素和相等的子集。

1 <= nums.length <= 200
1 <= nums[i] <= 100

思路

只要找到集合里能够出现 sum / 2 的子集总和，就算是可以分割成两个相同元素和子集了。要明确本题中我们要使用的是01背包，因为元素我们只能用一次。

只有确定了如下四点，才能把01背包问题套到本题上来。

背包的体积为sum / 2
背包要放入的商品（集合里的元素）重量为元素的数值，价值也为元素的数值
背包如果正好装满，说明找到了总和为 sum / 2 的子集。
背包中每一个元素是不可重复放入。

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

01背包中，dp[j] 表示：容量为j的背包，所背的物品价值最大可以为dp[j]。

本题中每一个元素的数值既是重量，也是价值。那么如果背包容量为target， dp[target]就是装满背包之后的重量，所以当 dp[target] == target 的时候，背包就装满了。

有装不满的时候嘛？

拿输入数组 [1, 5, 11, 5]，举例， dp[7] 只能等于 6，因为只能放进 1 和 5。而dp[6] 就可以等于6了，放进1 和 5，那么dp[6] == 6，说明背包装满了。

2.确定递推公式

01背包的递推公式为：dp[j] = Max(dp[j],dp[j-wieght[i]]+value[i]);本题，相当于背包里放入数值，那么物品i的重量是nums[i]，其价值也是nums[i]。

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

3.dp数组如何初始化

从dp[j]的定义来看，首先dp[0]一定是0。如果题目给的价值都是正整数那么非0下标都初始化为0就可以了，如果题目给的价值有负数，那么非0下标就要初始化为负无穷。这样才能让dp数组在递推的过程中取得最大的价值，而不是被初始值覆盖了。

// 题目中说：每个数组中的元素不会超过 100，数组的大小不会超过 200
// 总和不会大于20000，背包最大只需要其中一半，所以10001大小就可以了
vector<int> dp(10001, 0);

4.确定遍历顺序

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

//01背包
//nums = [1,5,11,5]
class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0,target = 0;
       
        for(int i = 0; i < nums.length;i++){
            sum += nums[i];
        }
        if (sum % 2 == 1) return false;//除不尽直接返回false
        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]);
            }
            if(dp[target] == target){//target = 11
	            return true;
	        }
        }
        for(int z = 0; z < dp.length;z++){
            System.out.print(dp[z]+" ");//0 1 1 1 1 5 6 6 6 6 10 11
        }
        
        return false;
    }
}

总结

1.sum除不尽直接返回false。

2.这是一道01背包应用类的题目，需要我们拆解题目，然后套入01背包的场景。

3.题目中物品是nums[i]，重量是nums[i]，价值也是nums[i]，背包体积是sum/2。

喝哈喝哈

关注

9
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
二维01背包 && 背包滚动数组 && 分割等和子集 DAY22

不理解dp数组中容量1 2 3 4这样的含义。不应该是背包的固定容量与物品的质量进行比较嘛？应该是背包容量从0开始，慢慢变大，对应每个不同容量的情况取得最大价值，直到容量遍历到题目中的容量为止。本质上还是由先前状态推出当前状态：背包空间为N ，为了得到最优解，先计算计算当背包空间为0 1 2 3 4…时的最优解，递推出背包空间为N时候的最优解。每个物品只有取与不取两种状态，所以叫01背包问题。在一维dp数组中，dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。
复制链接

扫一扫