(Java) LeetCode 416. Partition Equal Subset Sum —— 分割等和子集

Posted 2020-11-21 tengdai

Given a non-empty array containing only positive integers, find if the array can be partitioned into two subsets such that the sum of elements in both subsets is equal.

Note:

1. Each of the array element will not exceed 100.
2. The array size will not exceed 200.

Example 1:

Input: [1, 5, 11, 5]

Output: true

Explanation: The array can be partitioned as [1, 5, 5] and [11].

Example 2:

Input: [1, 2, 3, 5]

Output: false

Explanation: The array cannot be partitioned into equal sum subsets.

---

 

解法一：

一上来首先想到的并不是动态规划，而是广度优先搜索。首先观察一下题目，数组能被对半分的前提是数组元素和必须是偶数。那么本题就转化成了之前做过的一个问题，即LeetCode 40. Combination Sum II —— 组合总和 II，寻找target为数组元素总和一半的元素组合。同样每个元素只能用一次，还有重复元素。只是40题是找路径的结果集合，而本题只需要找其中任何一个满足条件的组合即可。代码照搬，稍加修改即可。

提交之后速度击败96.3%，证明这样做是可以的。可是看到有些排名靠前的答案一样用了DFS的思想但却没有排序，其中搜索下一个元素的地方改成了从数列尾部向前搜索。经过测试我发现这道题的test case应该都是排序过的。如果把用DFS思想还没有排序的代码复制过来，之后测试这个例子{100, 1, 1, ...(共98个1)}的话，是会提交超时的。可见LeetCode的test case不完整，且有些人钻了空子。分析一下为什么会超时，因为如果不排序，去重的工作量就会很大。如果不去重，就会一遍又一遍验证结果相同的集合，这样就会超时。所以这道题一定要去重，去重就一定要排序才不会超时。

 

解法二：

这道题还可以用动态规划，即将每次遍历到的数的放入和不放入结果集合的状态都存起来。有点像背包问题，每次放或者不放一个数进去都会影响以后是否能放入未来的数。

 

---

解法一（Java）

class Solution { 
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int num : nums)
            sum += num;
        if ((sum & 1) == 1) return false;
        sum >>= 1;
        Arrays.sort(nums); //排序以便去重
        return dfs(nums, 0, sum);
    }
    
    private boolean dfs(int[] nums, int i, int target) {
        if (target == 0) return true;
        if (i > nums.length || target < 0) return false;
        boolean mark = false; //相当于第40题的list，即把路径存储在这里
        for (int p = i; p < nums.length; p++) {
            int newSum = target - nums[p]; //添加到路径
            mark = mark || dfs(nums, p+1, newSum); //mark本身相当于回溯，并和搜索下一个节点的结果相结合
            while (p < nums.length - 1 && nums[p] == nums[p+1]) p++; //去重，利用排序特点
        }
        return mark;
    }
}

 

解法二（Java）

class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int num : nums)
            sum += num;
        if ((sum & 1) == 1) return false;
        sum >>= 1;
        boolean[] dp = new boolean[sum + 1];
        dp[0] = true;
        for (int j = 0; j < nums.length; j++) {
            for (int i = sum; i >=nums[j]; i--)
                dp[i] = dp[i] || dp[i-nums[j]];
            if (dp[sum]) return true;
        }
        return dp[sum];
    }
}