day41||第九章 动态规划part03|| 01背包问题 二维 01背包问题 一维 416. 分割等和子集

01背包问题 二维

好好练习ACM模式！

注意dp[i][j]数组的含义，是从[0,i]种类物品中任取（不一定取多少）放进容量为j的背包。

所以递推公式：

那么可以有两个方向推出来dp[i][j]，

• 不放物品i：由dp[i - 1][j]推出，即背包容量为j，里面不放物品i的最大价值，此时dp[i][j]就是dp[i - 1][j]。(其实就是当物品i的重量大于背包j的重量时，物品i无法放进背包中，所以背包内的价值依然和前面相同。)
• 放物品i：由dp[i - 1][j - weight[i]]推出，dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]的时候不放物品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]);

但只不过一开始就统一把dp数组统一初始为0，更方便一些。初始化先把所有的值置零，然后再把第一行和第0个物品大小相同的列的元素置为value[0],从这里往后都置为value[0].

import java.util.Scanner;
import java.util.Arrays;

public class Main{
    public static int n,bagweight;
    public static int solve(Scanner sc){
        int[] weight = new int[n];
        int[] value = new int[n];
        for(int i= 0;i<n;i++){
            weight[i] = sc.nextInt();
        }
        for(int j = 0;j<n;j++){
            value[j] = sc.nextInt();
        }
        int[][] dp = new int[n][bagweight+1];
        for(int j = weight[0];j<=bagweight;j++){

         dp[0][j]=value[0];
        }
        for(int i = 1;i<n;i++){
            for(int j = 0;j<bagweight+1;j++){
                if (j < weight[i]) dp[i][j] = dp[i - 1][j];
                else{
                    dp[i][j]=Math.max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i]);
                }
                
            }
            
        }
        return dp[n-1][bagweight];
    }
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNextInt()) {
            n = sc.nextInt();
            bagweight = sc.nextInt();
            int res = solve(sc);
            System.out.println(res);
        }
    }
}

而且还有一点，对于dp[i][j]，无非就两种情况，要么放i，要么不放i，所以就有两个式子，比较出二者的最大值。先不写了，所以从两个式子就可以看出，一个是i-1，即从上面往下推出来的，一定相邻，还有一个是从左上方推到过来的，是左上方，不一定相邻，但是一定在上一层。

01背包问题 一维

注意带注释的部分，还是需要fori

import java.util.Scanner;
import java.util.Arrays;

public class Main{
    public static int n,bagweight;
    public static int solve(Scanner sc){
        int[] weight = new int[n];
        int[] value = new int[n];
        for(int i= 0;i<n;i++){
            weight[i] = sc.nextInt();
        }
        for(int j = 0;j<n;j++){
            value[j] = sc.nextInt();
        }
        int[] dp = new int[bagweight+1];

for(int i=0;i<n;i++){
        for(int j = bagweight;j>=weight[i];j--){
            dp[j]=Math.max(dp[j],dp[j-weight[i]]+value[i]);
            
        }
}

        return dp[bagweight];
    }
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNextInt()) {
            n = sc.nextInt();
            bagweight = sc.nextInt();
            int res = solve(sc);
            System.out.println(res);
        }
    }
}

416. 分割等和子集

class Solution {
    public boolean canPartition(int[] nums) {
        int sum =0, target =0;
        for(int num:nums){
            sum+=num;
        }
        if (sum % 2 == 1) return false;
        target = sum/2;
        int[] dp = new int[target+1];//背包位置可以是0
        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(target == dp[target]){
        //     return true;
        // }else{
        //     return false;
        // }
        return dp[target] == target;
    }
}