代码随想录算法训练营Day35|01背包的二维dp数组和一维dp数组解法、416. 分割等和子集

 01背包的二维dp数组和一维dp数组解法

 dp[i][j]:从0到i物品中取，放入最大容量为j的行李空间中，能装的最大价值是多少。

递推公式：max(dp[i-1][j],dp[i-1][j-weight[i]] + value[i]);这里是不放物品i和放物品i的情况下，取最大值。

初始化：第一列初始化为0，因为容量从0开始，没容量你装啥？第一行从能放下第一个物品的容量开始更新，往后容量都是这个物品的价值，因为物品只有一件，所以不管你包多大，只算当前装进去的物品价值。

遍历顺序：从前往后遍历，先遍历物品或者行李空间都可以。

打印dp数组：代码中给了打印的代码，只需把1==0 改成1==1即可

import java.util.Scanner;
public class Main{
    public static void main (String[] args) {
        /* code */
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        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();
        }
        int[][] dp = new int[m][n+1];
        for(int i = weight[0]; i <= n; i++){
            dp[0][i] = value[0];
        }
        
        for(int i = 1; i < m; i++){
            for(int j =1; j <= n; 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]);
                }
            }
        }
        
        if(1==0){
            for(int i = 0 ; i < m;i++){
                for(int j = 0 ; j <n+1;j++){
                    System.out.print(dp[i][j]);
                    System.out.print("-");
                }
                System.out.println();
            }
        }

        System.out.println(dp[m-1][n]);
    }
} 

滚动数组(一维数组)解法：

 dp[j]:放入最大容量为j的行李空间中，能装的最大价值是多少。

递推公式：

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

;这里是不放物品i和放物品i的情况下，取最大值。

初始化：d[0] = 0

遍历顺序：先遍历物品再遍历空间。遍历空间的时候要从后往前遍历。

如果从前往后遍历的话，会导致一个物品放入多次，而从后往前遍历的话，因为前面的数据都不包含当前物品。即使需要更新加入当前物品，也会先减去当前重量在加。

打印dp数组：略

import java.util.Scanner;
public class Main{
    public static void main (String[] args) {
        /* code */
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        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();
        }
        
        int[]dp = new int[n + 1];
        
        dp[0] = 0;
        
        for(int i = 0; i < m; i++){
            for(int j = n; j >=weight[i]; j--){
                dp[j] = Math.max(dp[j],dp[j-weight[i]] + value[i]);
            }
        }
        
        System.out.println(dp[n]);
    }
} 

416. 分割等和子集

        本题元素中的值既是重量，也是价值。

滚动数组(一维数组)解法：

 dp[j]:放入最大容量为j的数组中，能装的最大总值是多少。

递推公式：

dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);            

初始化：d[0] = 0，不初始化也可以本题

遍历顺序：先遍历元素再遍历集合大小。遍历集合大小的时候要从后往前遍历。

打印dp数组：略

class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for(int i:nums){
            sum+=i;
        }
        if(sum % 2 != 0) return false;
        sum = sum/2;
        int[] dp = new int[sum+1];
        for(int i = 0; i < nums.length; i++){
            for(int j = sum; j>=nums[i]; j--){
                dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);             
                //System.out.print(j);
                //System.out.print('-');
                //System.out.println(dp[j]);
                //if(dp[j]==sum) return true;
            }
            if(dp[sum]==sum) return true;
        }
        if(1 == 0){
            for(int i = 0 ; i < dp.length; i++){
                System.out.println(dp[i]);
            }
        }
        return false;
    }
}