Leetcode 题解 - 动态规划-0-1 背包（2）：划分数组为和相等的两部分

[LeetCode] Partition Equal Subset Sum 相同子集和分割

偶数， 除以2， 或方法求解

 

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:
Both the array size and each of the array element will not exceed 100.

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.

这道题给了我们一个数组，问我们这个数组能不能分成两个非空子集合，使得两个子集合的元素之和相同。那么我们想，原数组所有数字和一定是偶数，不然根本无法拆成两个和相同的子集合，那么我们只需要算出原数组的数字之和，然后除以2，就是我们的target，那么问题就转换为能不能找到一个非空子集合，使得其数字之和为target。开始我想的是遍历所有子集合，算和，但是这种方法无法通过OJ的大数据集合。于是乎，动态规划 Dynamic Programming 就是我们的不二之选。我们定义一个一维的dp数组，其中dp[i]表示原数组是否可以取出若干个数字，其和为i。那么我们最后只需要返回dp[target]就行了。初始化dp[0]为true，由于题目中限制了所有数字为正数，那么就不用担心会出现和为0或者负数的情况。关键问题就是要找出状态转移方程了，我们需要遍历原数组中的数字，对于遍历到的每个数字nums[i]，需要更新dp数组，我们的最终目标是想知道dp[target]的boolean值，就要想办法用数组中的数字去凑出target，因为都是正数，所以只会越加越大，那么加上nums[i]就有可能会组成区间 [nums[i], target] 中的某个值，那么对于这个区间中的任意一个数字j，如果 dp[j - nums[i]] 为true的话，说明现在已经可以组成 j-nums[i] 这个数字了，再加上nums[i]，就可以组成数字j了，那么dp[j]就一定为true。如果之前dp[j]已经为true了，当然还要保持true，所以还要‘或’上自身，于是状态转移方程如下：

dp[j] = dp[j] || dp[j - nums[i]]         (nums[i] <= j <= target)

有了状态转移方程，那么我们就可以写出代码了，这里需要特别注意的是，第二个for循环一定要从target遍历到nums[i]，而不能反过来，想想为什么呢？因为如果我们从nums[i]遍历到target的话，假如nums[i]=1的话，那么[1, target]中所有的dp值都是true，因为dp[0]是true，dp[1]会或上dp[0]，为true，dp[2]会或上dp[1]，为true，依此类推，完全使我们的dp数组失效了，参见代码如下：

1. 要想到数组元素的和必须是偶数

2.定义一个一维的dp数组，其中dp[i]表示原数组是否可以取出若干个数字，其和为i，只需要返回dp[target]

3.如果 dp[j - nums[i]] 为true的话，说明现在已经可以组成 j-nums[i] 这个数字了，再加上nums[i]，就可以组成数字j了，那么dp[j]就一定为true。如果之前dp[j]已经为true了，当然还要保持true，所以还要‘或’上自身

4.这里需要特别注意的是，第二个for循环一定要从target遍历到nums[i]，而不能反过来，想想为什么呢？因为如果我们从nums[i]遍历到target的话，假如nums[i]=1的话，那么[1, target]中所有的dp值都是true，因为dp[0]是true，dp[1]或上dp[0]，为true，dp[2]会或上dp[1]，为true，依此类推，完全使我们的dp数组失效了

5 可以给数组排个序来看, 这里既然是先判断出可以整数合适偶数了 那么只要找到第一个完成dp[target]的子序列就代表后面子序列的和一一定是dp[target]

但其实不用排序也可以 因为每个从0 到 target 会以此比较 

class Solution {
    
    public boolean canPartition(int[] nums) {
    int sum = computeArraySum(nums);
    if (sum % 2 != 0) {
        return false;
    }
    int W = sum / 2;
    boolean[] dp = new boolean[W + 1];
    dp[0] = true;
    for (int num : nums) {                 // 0-1 背包一个物品只能用一次
        for (int i = W; i >= 1; i--) {   // 从后往前，先计算 dp[i] 再计算 dp[i-num]
            if(i >= num)
                dp[i] = dp[i] || dp[i - num];
        }
    }
    return dp[W];
}

    private int computeArraySum(int[] nums) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        return sum;
    }
}

最初版本

class Solution {
    public boolean canPartition(int[] nums) {
        int sum = computeArraySum(nums);
    if (sum % 2 != 0) {
        return false;
    }
    int W = sum / 2;
    int n = nums.length;
    boolean[][] dp = new boolean[n + 1][W + 1];
    dp[0][0] = true;
    for (int i = 1; i <= n; i++) {
        int num = nums[i-1];        // 0-1 背包一个物品只能用一次
        for (int j = 1; j <= W; j++) { 
            if(j >= num)// 从后往前，先计算 dp[i] 再计算 dp[i-num]
                dp[i][j] = dp[i-1][j] || dp[i - 1][j - num];
            else
                dp[i][j] = dp[i-1][j];
        }
    }
    return dp[n][W];
}

    private int computeArraySum(int[] nums) {
        int sum = 0;
        for (int num : nums) {
        sum += num;
        }
        return sum;
    }
}