动态规划03（二维01背包，一维01背包，leetcode416）-CSDN博客

本文链接：https://blog.csdn.net/weixin_62372284/article/details/139882288

参考资料：

https://programmercarl.com/%E8%83%8C%E5%8C%85%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%8001%E8%83%8C%E5%8C%85-1.html

题目描述：

输入示例

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

输出示例

思路分析：

dp[i][j]：0~（i-1）中的物品任放，放进容量为j的包的最大价值

状态转移方程：dp[i][j]= max(不放i，放i)

代码实现：

func(int[] weight, int[] value,int bagSize){
    int n=weight.length;
    int[][] dp=new int[n][bagSize+1];
    
    for(int j=weight[0];j<=bagSize;j++){
        dp[0][j]=value[0];
    }

    for(int i=1;i<weight.length;i++){
        for(int j=1;j<=bagSize;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][bagSize];
}

题目同上

题目描述：

同上

思路分析：

结论：dp[j]：容量为j的背包能装的最大价值为dp[j]

先遍历物品再遍历背包，倒序遍历

初始化：为避免答案被覆盖，所以均初始化成0.

原因：这样可以避免物品重复放入背包。

代码实现：

class int func(int[] weight, int[] value,int bagSize){
    int n=weight.length;
    int[] dp=new int[bagWeight+1];
    //初始化：默认都初始化成0
    
    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];
}

416. 分割等和子集

题目描述：

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

示例 1：

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

思路分析：

转化为01背包问题：计算出数组总和为sum，设置背包容量为sum/2。判断能否装满容量为sum/2的背包。即判断dp[targrt]==target

代码实现：

class Solution {
    public boolean canPartition(int[] nums) {
        int sum=0;
        for(int item:nums){
            sum+=item;
        }
        if(sum%2==1) return false;
        int 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) return true;
        return false;
    }
}