【NO.87】LeetCode HOT 100—416. 分割等和子集

题目：416. 分割等和子集

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

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

输入：nums = [1,2,3,5]
输出：false
解释：数组不能分割成两个元素和相等的子集。

提示：

1 <= nums.length <= 200
1 <= nums[i] <= 100

解题

方法一：动态规划

0-1背包问题：分割成两个子集，使得两个子集的元素和相等。转换下就是背包容量为和的一半（target），从nums数组中挑选元素，使得和=target。

// 时间，空间复杂度都为O(n^2)
class Solution {
    public boolean canPartition(int[] nums) {
        // 0-1背包问题：分割成两个子集，使得两个子集的元素和相等。
        // 转换下就是背包容量为和的一半（target），从nums数组中挑选元素，使得和=target。

        int size = nums.length;
        if (size == 1) {
            return false;
        }
        int sum = 0;
        int maxNum = 0;
        for (int i : nums) {
            sum += i;
            if (i > maxNum) {
                maxNum = i;
            }
        }
        if (sum % 2 == 1) {
            // 和为奇数，返回false
            return false;
        }
        int target = sum/2;
        if (maxNum > target) {
            // 数组里最大的数 大于 target，直接返回false
            return false;
        }

        // 动态规划，定义dp,前i个元素是否可以组合为j，注意第i个物品的质量为nums[i-1]
        boolean[][] dp = new boolean[size+1][target+1];

        // base case 就是 dp[..][0] = true 和 dp[0][..] = false, 空间为0时默认装满了，没有物品时不能装啊
        for (int i = 0; i <= size; i++) {
            dp[i][0] = true;
        }
        // 遍历二维数组，填充值，最后得到dp[size][target]的值，就是结果
        for (int i = 1; i <= size; i++) {
            for (int j = 1; j <= target; j++) {
                if (j >= nums[i-1]) {
                    // 此时空间 > 物品质量，当前物品可选可不选
                    // 不选是 dp[i-1][j]
                    // 选是dp[i-1][j - nums[i-1]], 上一个物品可选的空间就是 总空间j减去当前物品的质量
                    dp[i][j] = dp[i-1][j] | dp[i-1][j - nums[i-1]];
                } else {
                    // 此时空间 < 物品质量，无法选择，只能继承上一个
                    dp[i][j] = dp[i-1][j];
                }
            }
        }

        return dp[size][target];
    }
}

方法二：动态规划优化

空间优化，可以发现在计算 dp 的过程中，每一行的dp值都只与上一行的dp值有关，因此只需要一个一维数组即可将空间复杂度降到 O(n)。
需要注意的是第二层的循环我们需要从大到小计算，因为如果我们从小到大更新 dp值，那么在计算 dp[j]值的时候，dp[j−nums[i]]已经是被更新过的状态，不再是上一行的dp值

class Solution {
    public boolean canPartition(int[] nums) {
        // 0-1背包问题：分割成两个子集，使得两个子集的元素和相等。
        // 转换下就是背包容量为和的一半（target），从nums数组中挑选元素，使得和=target。

        int size = nums.length;
        if (size == 1) {
            return false;
        }
        int sum = 0;
        int maxNum = 0;
        for (int i : nums) {
            sum += i;
            if (i > maxNum) {
                maxNum = i;
            }
        }
        if (sum % 2 == 1) {
            // 和为奇数，返回false
            return false;
        }
        int target = sum/2;
        if (maxNum > target) {
            // 数组里最大的数 大于 target，直接返回false
            return false;
        }

        boolean[] dp = new boolean[target+1];
        dp[0] = true;
        for (int i = 0; i < size; i++) {
            for (int j = target; j >= nums[i]; j--) {
                dp[j] = dp[j] | dp[j - nums[i]];
            }
        }

        return dp[target];
    }
}