416. 分割等和子集

 416. 分割等和子集

0-1背包问题，先来一个二维数组的

​
class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        int maxNum = 0;

        for(int num:nums){
            sum += num;
            maxNum = Math.max(maxNum,num);
        }
        //排除数组长度为1，或者和为奇数的情况
        if(nums.length == 1 || sum % 2 == 1) return false;
        //和为偶数时，当maxNum > target直接返回false
        int target = sum / 2;
        if(maxNum > target) return false;

        //初始化dp数组，选择第0个数，当j = nums[0] 时为true，这个true是指取 小于等于i的数值的和可以为j
        boolean[][] dp = new boolean[nums.length][target + 1];
        dp[0][nums[0]] = true;
        //无论i截取到几，j = 0，不取都可以满足，所以都为true
        for(int i = 0;i < nums.length;i++){
            dp[i][0] = true;
        }

        for(int i = 1;i < nums.length;i++){
            for(int j = 1; j <= target;j++){
                //当 j > nums[i]，可以选择不取或者取，如果不取已经满足了，即为true，则不取，
                //如果上一层j-nums[i]为true，则取了也可以完成，否则为false，不能完成条件
                if(j > nums[i]){
                    dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i]];
                //如果j < nums[i]，则直接照搬上一层的结果即可，因为取不了nums[i]
                }else{
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        return dp[nums.length - 1][target];
    }
}

​

再来个一维数组的

class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        int maxNum = 0;

        for(int num:nums){
            sum += num;
            maxNum = Math.max(maxNum,num);
        }
        //排除数组长度为1，或者和为奇数的情况
        if(nums.length == 1 || sum % 2 == 1) return false;
        //和为偶数时，当maxNum > target直接返回false
        int target = sum / 2;
        if(maxNum > target) return false;

        
        boolean[] dp = new boolean[target + 1];

        dp[0] = true;

        //第一次循环借助dp[0] = true，得到dp[nums[0]] = true;
        //第二次循环得到dp[nums[1]] = true;以及dp[nums[0] + nums[1]] = true;
        //第三次循环得到0,1，2能组合起来的j为true，直到遍历完i个数，获得所有的组合为true再看target是否为true
        for(int i = 0;i < nums.length;i++){
            for(int j = target; j >= nums[i];j--){
                dp[j] = dp[j] || dp[j - nums[i]];
            }
        }
        return dp[target];
    }
}