随想录Day41|● 01背包问题，你该了解这些！ ● 01背包问题，你该了解这些！滚动数组 ● 416. 分割等和子集

最新推荐文章于 2024-11-11 22:10:43 发布

YeMing1943

最新推荐文章于 2024-11-11 22:10:43 发布

阅读量148

点赞数

文章标签：算法动态规划

本文链接：https://blog.csdn.net/YeMing1943/article/details/134208293

版权

背包问题基础

背包问题大致如下图所示

其中最基础的就是01背包了

01背包

问题原型:

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

在下面的讲解中，我举一个例子：

背包最大重量为4。

物品为：

	重量	价值
物品0	1	15
物品1	3	20
物品2	4	30

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

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

对于背包问题，有一种写法，是使用二维数组，即dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。

只看这个二维数组的定义，大家一定会有点懵，看下面这个图：

要时刻记着这个dp数组的含义，下面的一些步骤都围绕这dp数组的含义进行的，如果哪里看懵了，就来回顾一下i代表什么，j又代表什么。

2.确定递推公式
dp[i] = Math.max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i])
只有两种情况
一.放i物品
放i物品意味着i物品是一定在结果中的,所以要先加入i物品进背包中
此时背包的价值有value[i],随后在剩余的容量[j-weight[i]]中求出最大的价值
因为i物品已经被添加,所以可取物品范围应该是[i-1]
所以这种情况的最大价值为value[i]+dp[i-1][j-weight[i]]

二.不放i物品
相当于在当前容量为j的背包中任取下标[0,i-1]的物品的最大价值即dp[i-1][j];

3.dp数组初始化
根据推导公式可以看出,想要使用递推公式,上一层的左上区域决不能为空
所以要初始化dp[0][j]与dp[i][0]的区域

for(int i=weight[0];i<n;i++){
    //只放物品0的情况
    dp[0][i] = value[0];
}

确定遍历顺序

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

动态规划-背包问题3

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

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

5.打印dp数组

最后代码整体如下

public static void main(String[]args){

        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int m = sc.nextInt();
            int n = sc.nextInt()+1;
            //因为n多一种为0的情况,所以+1
            int[][] dp = new int[m][n];
            //接收物品信息
            int[] weight = new int[m];
            int[] value = new int[m];
            for(int i = 0;i<m;i++){
                weight[i] = sc.nextInt();
            }
            for(int i = 0;i<m;i++){
                value[i] = sc.nextInt();
            }

            for(int i=weight[0];i<n;i++){
                //只放物品0的情况
                dp[0][i] = value[0];
            }
            //4.遍历顺序,先遍历物品先遍历背包皆可,但是要保证遍历顺序是从左到右,从上往下的
            for(int i =1;i<m;i++){
                for(int j = 1;j<n;j++){
                    //判断下当前背包能不能装下i物品防止越界
                    if(j<weight[i]){
                        dp[i][j] = dp[i-1][j];
                        continue;
                    }
                    dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i]);
                }
            }
            //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();
            }*/
            System.out.println(dp[m-1][n-1]);




        }
    }

416. 分割等和子集

给你一个 只包含正整数 的非空数组 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

代码:

class Solution {
   public static boolean canPartition(int[] nums) {
        //套入01背包问题
        //题目中求数组分割成两个子集，使得两个子集的元素和相等。
        //那么子集的元素和就是nums所有元素和sum/2,因为最后两个子集元素和是相等的
        //那么只要求出有一个子集元素和=sum/2即可,剩下的元素自动视为一个子集
        //用背包问题的视角来看的话,就是每个元素的价值和重量相同,背包的容量即为sum/2

        //1.dp[i][j]代表在[0,i]中的元素任选,背包的容量为j,使得携带物品的价值最大
        int sum =0;
        for (int num : nums) {
            sum+=num;
        }
        if(sum%2!=0)return false;//奇数不可能凑出两个元素和一致的整数子集
        sum = sum/2+1;//+1是因为有一个0的情况
        int[][] dp = new int[nums.length][sum];
        //2.递推公式为dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-weigh[i]]+value[i]);
        //3.初始化d[0][j],dp[i][0]的部分
        for(int i = nums[0];i<sum;i++){
            dp[0][i] = nums[0];
        }

        //4.从左往右从上往下遍历
        for(int i =1;i<nums.length;i++){
            for(int j =1;j<sum;j++){
                if(nums[i]>j){
                    //排除j-nums[i]<0的情况
                    dp[i][j] = dp[i-1][j];
                }
                else{
                    dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-nums[i]]+nums[i]);
                }

            }
        }
        //5.打印


        return dp[nums.length-1][sum-1]==(sum-1);



    }
}

感谢观看!