LeetCode Day42|●01背包问题 二维（46.携带研究材料）● 01背包问题 一维（46.携带研究材料）●416. 分割等和子集(初始化和遍历顺序式难点)

day42-1 ●01背包问题 二维

背包问题概述

01背包、完全背包、多重背包、混合背包、分组背包
01背包：有n种物品每种物品只有一个
完全背包：有n种物品每种物品有无限个
多重背包：有n种物品每种物品的个数不相同

背包问题：每个物品有自己的重量也有自己的价值，一个重量最多放m的背包，问这个背包最多能装价值为多少的物品

背包暴露解法

暴力解法：每个物品取与不取，回溯算法进行暴力搜索
回溯算法就是解决多重for循环的

dp数组含义

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

递推公式

dp数组初始化

遍历顺序/打印dp数组

二维数组实现的背后问题两种顺序都可以

46.携带研究材料

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        // 物品种类 M
        int M = sc.nextInt();
        // 背包容量 N
        int N = sc.nextInt();
        
        int[] values = new int[M];
        int[] weights = 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];
        
        // 初始化
        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++){
                // 如果装不下这个物品,那么就继承dp[i - 1][j]的值
                if(weights[i] > j){
                    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]);
                }
            }
        }
        System.out.println(dp[M - 1][N]);
    }
}

day42-2 ● 01背包问题 一维

一维dp 01背包概述

i、j 和dp[i][j] 的含意:是0到物品i之间的物品任意取放进容量为j的最大价值为dp[i][j]
滚动数组解题

dp数组含义

dp[j]: 容量为 j 的背包所能装的最大价值为dp[j]

递推公式

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

• 一个是取dp[j]相当二维数组中的[i - 1][j]，即不放物品
• 另一个是取dp[j - weight[i]] + value[i], 即放物品i

dp数组初始化

dp[0]就应该是0，因为背包容量为0所背的物品的最大价值就是0
避免覆盖问题:初始化为0的原因是让dp数组在递归公式的过程中取的最大的价值，而不是被初始值覆盖

遍历顺序

倒序遍历是为了保证物品i只被放入一次

代码实现

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        // 物品种类 M
        int M = sc.nextInt();
        // 背包容量 N
        int N = sc.nextInt();
        
        int[] values = new int[M];
        int[] weights = 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();
        }
        // 动态规划数组，dp[j]代表容量为j时最大价值
        int[] dp = new int[N + 1];
        // 填充动态规划表
        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]);
    }
}

day42-3 ●416. 分割等和子集

解题思路

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

回溯算法暴力搜索也行但是可能会超时

在集合中每个元素只能使用一次，然后集合里面的元素能不能装满容量为11的背包，即是01背包问题

dp含意

dp[j]:容量为j的背包它所背的最大价值为dp[j]
重量=价值

递推公式

weight[i] = value[i];

初始化

dp[0] = 0;
正整数的最小值避免覆盖问题

遍历顺序

遍历物品顺序
遍历背包逆序

代码实现

class Solution {
    // 一维数组版
    public boolean canPartition(int[] nums) {
        if (nums == null || nums.length == 0) {
            return false;
        }
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        // 总和为奇数，不能平分
        if (sum % 2 != 0) {
            return false;
        }
        int target = sum / 2;
        // 初始化+dp创建
        int[] dp = new int[target + 1];
        for (int i = 0; i < nums.length; i++) {
            for (int j = target; j >= nums[i]; j--) {
                // 物品 i 的重量是num[i], 其价值也是nums[i]
                dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);
            }
            // 剪枝
            if (dp[target] == target) {
                return true;
            }
        }
        return dp[target] == target;
    }
}

打印

使用二维数组的时候可以打印

总结

难点在：

• 抽象成01背包问题
• 如何初始化
• 确定遍历顺序