分割等和子集

分割等和子集

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

注意:

1. 每个数组中的元素不会超过 100
2. 数组的大小不会超过 200

示例 1:

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

示例 2:

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

方法一：DFS
我的方法(超时)

public boolean canPartition(int[] nums) {
    int sum = 0;
    for (int num : nums) {
        sum += num;
    }
    if (sum % 2 != 0) {
        return false;
    }
    return dfs(nums, 0, 0, sum / 2);
}

public boolean dfs(int[] nums, int i, int partSum, int sum) {
    if (partSum == sum) {
        return true;
    }
    if (partSum > sum || i == nums.length) {
        return false;
    }
    return dfs(nums, i + 1, partSum + nums[i], sum) || dfs(nums, i + 1, partSum, sum);
}

改进：将数组排序，先考虑较大的元素，这样好剪枝

public boolean canPartition(int[] nums) {
    int sum = 0;
    Arrays.sort(nums);
    for (int num : nums) {
        sum += num;
    }
    if (sum % 2 != 0) {
        return false;
    }
    return dfs(nums, nums.length - 1, 0, sum / 2);
}

public boolean dfs(int[] nums, int i, int partSum, int sum) {
    if (partSum == sum) {
        return true;
    }
    if (partSum > sum || i < 0 || nums[i] > sum) {
        return false;
    }
    return dfs(nums, i - 1, partSum + nums[i], sum) || dfs(nums, i - 1, partSum, sum);
}

方法二：动态规划
其实是背包问题

dp[i][j]表示从nums[0]到nums[i]中挑一些数，每个数最多用一次，能否使和为j

public boolean canPartition(int[] nums) {
    int sum = 0;
    for (int num : nums) {
        sum += num;
    }
    if (sum % 2 != 0) {
        return false;
    }
    sum /= 2;
    boolean[][] dp = new boolean[nums.length][sum + 1];
    if (nums[0] <= sum) {
        //只考虑第一个数时，只有和为第一个数才为true
        dp[0][nums[0]] = true;
    }
    for (int i = 1; i < nums.length; i++) {
        for (int j = 0; j <= sum; j++) {
            dp[i][j] = dp[i - 1][j];//不选择第nums[i]
            if (j - nums[i] >= 0) {
                //dp[i - 1][j - nums[i]]选择num[i]
                dp[i][j] = dp[i][j] || dp[i - 1][j - nums[i]];
            }
        }
    }
    return dp[nums.length - 1][sum];
}

空间优化：
填表的时候只用到了上一行，所以可压缩为一维数组

public boolean canPartition(int[] nums) {
    int sum = 0;
    for (int num : nums) {
        sum += num;
    }
    if (sum % 2 != 0) {
        return false;
    }
    sum /= 2;
    boolean[] dp = new boolean[sum + 1];
    if (nums[0] <= sum) {
        dp[nums[0]] = true;
    }
    for (int i = 1; i < nums.length; i++) {
        //由于填表时用到了正上方和左上方的元素，为避免新的值覆盖了原有的值，所以从后往前遍历
        for (int j = sum; j >= 0; j--) {
            if (j - nums[i] >= 0) {
                dp[j] = dp[j] || dp[j - nums[i]];
            }
        }
    }
    return dp[sum];
}