Java分割等和子集

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

1、

class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for(int i : nums){
            sum += i;
        }
        if((sum & 1) == 1 ){
            return false;
        }
        sum = sum / 2;
        int n = nums.length;

        boolean[][] dp = new boolean[n+1][sum+1];

        for(int i = 0;i <= n;i++){
            dp[i][0] = true;
        }

        for(int i = 1;i <= n;i++){
            for(int j = 1;j <= sum;j++){
                if(j - nums[i-1] < 0){
                    //背包容量不足，不能装入第i个元素
                    dp[i][j] = dp[i-1][j];
                }else {
                    //背包容量足够，可以选择不放入或者放入
                    dp[i][j] = dp[i-1][j] || dp[i-1][j - nums[i-1]];
                }
            }
        }
        return dp[n][sum];
    }
}

执行用时：29 ms, 在所有 Java 提交中击败了33.73%的用户

内存消耗：42.5 MB, 在所有 Java 提交中击败了23.20%的用户

通过测试用例：117 / 117

2、优化空间结构

class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for(int i : nums){
            sum += i;
        }
        if((sum & 1) == 1 ){
            return false;
        }
        sum = sum / 2;
        int n = nums.length;

        //boolean[][] dp = new boolean[n+1][sum+1];
        boolean[] dp = new boolean[sum+1];

        dp[0] = true;

        for(int i = 0;i < n;i++){
            for(int j = sum;j > 0;j--){
                if(j - nums[i] >= 0){
                    dp[j] = dp[j] || dp[j - nums[i]];
                }
            }
        }
        return dp[sum];
    }
}

执行用时：21 ms, 在所有 Java 提交中击败了62.39%的用户

内存消耗：39.8 MB, 在所有 Java 提交中击败了88.09%的用户

通过测试用例：117 / 117