[leetcode 中等 动态规划]416. 分割等和子集

题目描述

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

注意:

每个数组中的元素不会超过 100
数组的大小不会超过 200
示例 1:

输入: [1, 5, 11, 5]

输出: true

解释: 数组可以分割成 [1, 5, 5] 和 [11].

示例 2:

输入: [1, 2, 3, 5]

输出: false

解释: 数组不能分割成两个元素和相等的子集.

动态规划

class Solution {
    public boolean canPartition(int[] nums) {
        // 做这道题需要做一个等价转换：是否可以从输入数组中挑选出一些正整数，使得这些数的和 等于 整个数组元素的和的一半。
        int len = nums.length;
        int sum = 0;
        for(int num:nums){
            sum+=num;
        }
        if(sum%2 ==1) return false;

        int taget = sum/2;
        //dp[n][j]. 代表在范围0-n 能否得到和为j的组合
        boolean[][] dp = new boolean[len][taget+1];
        
        if(nums[0]<=taget) dp[0][nums[0]] = true;

        for(int i=1;i<len;i++){
            for(int j=0;j<=taget;j++){
                //0-（n-1）的范围就就可以加出来j 后面也肯定可以
                //如果0-（n-1） 没有加出来j就需要用两个if进行判断
                dp[i][j] = dp[i - 1][j];

                //如果当前的数就等于j 那肯定可以合成
                if (nums[i] == j) {
                    dp[i][j] = true;
                    continue;
                }

                //如果i-1的范围内 可以得到 j-nums[i]  那现在加上nums[i]就可以了 
                if(nums[i]<j){
                    dp[i][j] = dp[i-1][j]||dp[i-1][j-nums[i]] ;
                }
                // System.out.println(i+". "+j);
                // System.out.println(dp[i][j]);

            }
        }
        return dp[len-1][taget];    
    }
}

动态规划+简单的剪枝

public class Solution {

    public boolean canPartition(int[] nums) {
        int len = nums.length;
        if (len == 0) {
            return false;
        }
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        if (sum%2 == 1)  return false;

        int target = sum / 2;
        boolean[][] dp = new boolean[len][target + 1];
        
	    //初始化成为 true 虽然不符合状态定义，但是从状态转移来说是完全可以的
	    //这里让dp[0][0] 为true就是为了解决后面 nums[i] == j的情况
        dp[0][0] = true;

        if (nums[0] == target) {
            dp[0][nums[0]] = true;
        }
        
        for (int i = 1; i < len; i++) {
            for (int j = 0; j <= target; j++) {
                dp[i][j] = dp[i - 1][j];
                if (nums[i] <= j) {
                    dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i]];
                }
            }

            // 由于状态转移方程的特殊性，提前结束，可以认为是剪枝操作
            if (dp[i][target]) {
                return true;
            }
        }
        return dp[len - 1][target];
    }
}

动态规划+空间优化

public class Solution {

    public boolean canPartition(int[] nums) {
        int len = nums.length;
        if (len == 0) {
            return false;
        }
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        if (sum%2 == 1)  return false;

        int target = sum / 2;
        boolean[] dp = new boolean[target + 1];
        dp[0] = true;
        if (nums[0] == target) {
            dp[nums[0]] = true;
        }

        for (int i = 1; i < len; i++) {
            //从target开始循环 开始循环j到target的值
            for(int j = target; nums[i] <= j; j--){
                if (dp[target])  return true;
                //后面的dp[j] 就相当与上一次的j 但循环的顺序一定要是倒着来的 才能对
                dp[j] = dp[j] || dp[j - nums[i]];
            }
        }
        return dp[target];
    }
}