算法---LeetCode 416. 分割等和子集

1. 题目

原题链接

给你一个 只包含正整数 的 非空 数组 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

Related Topics 动态规划
👍 813 👎 0

2. 题解

2.1 解法1: 动态规划

思路: 题意转化为 是否可以从输入数组中挑选出一些正整数，使得这些数的和 等于 整个数组元素的和的一半设为 target

1. 状态数组: dp[i][j] 表示从数组的 [0,i] 下标范围内选取若干个正整数（可以是 0 个），是否存在一种选取方案使得被选取的正整数的和等于 j
2. 状态转移:

• a. 不选 nums[i], dp[i][j]= dp[i-1][j]
• b. 选 nums[i]
  当 j>=nums[i], dp[i][j] = dp[i-1][j-nums[i]]

3. 初始化: 和为0,都为 true, dp[i][0]=true, 同时填充第0行, dp[0][nums[0]]=true
4. 输出结果: dp[len-1][target], 即数组选一些数的和可以为整个数据元素和的一半
5. 情况特判: 先求数组总和, 若不为偶数, 则直接返回false

   class Solution {
       public boolean canPartition(int[] nums) {
           int sum = 0;
           int len = nums.length;
           for (int i = 0; i < len; i++) {
               sum += nums[i];
           }
           if (sum % 2 == 1) {
               return false;
           }
           int target = sum / 2;
           boolean[][] dp = new boolean[len][target + 1];
           for (int i = 0; i < len; i++) {
               dp[i][0] = true;
           }
           if (nums[0] <= target) {
               dp[0][nums[0]] = true;
           }
           for (int i = 1; i < len; i++) {
               for (int j = 1; j <= target; j++) {
                   if (nums[i] <= j) {
                       dp[i][j] = dp[i - 1][j - nums[i]] || dp[i - 1][j];
                   } else {
                       dp[i][j] = dp[i - 1][j];
                   }
               }
           }
           return dp[len - 1][target];
       }
   }

空间优化: 由于更新dp 时, 每一行只与上一行有关, 所以可以将 dp 降一维度,
但需要特别注意的是, 第二层的循环我们需要从大到小计算，因为如果我们从小到大更新 dp 值，
那么在计算 dp[j] 值的时候，dp[j−nums[i]] 已经是被更新过的状态，不再是上一行的 dp 值

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

参考:
官方题解
动态规划（转换为 0-1 背包问题）