leetcode *416. 分割等和子集（2020.10.11）

最新推荐文章于 2022-11-24 20:42:38 发布

原创最新推荐文章于 2022-11-24 20:42:38 发布 · 284 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #动态规划

Leetcode 同时被 2 个专栏收录

592 篇文章

订阅专栏

动态规划

69 篇文章

订阅专栏

这是一篇关于LeetCode 416题目的解题博客。通过动态规划的方法，分析如何判断一个包含正整数的数组是否能分割成两个和相等的子集。文章详细介绍了动态规划的准备工作，包括数组元素和的判断，以及状态转移方程，最后优化空间复杂度至O(target)。

【题目】*416. 分割等和子集

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

注意:
每个数组中的元素不会超过 100
数组的大小不会超过 200

示例 1:

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

示例 2:

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

【解题思路1】动态规划

准备工作

根据数组的长度 n 判断数组是否可以被划分。如果 n<2n<2，则不可能将数组分割成元素和相等的两个子集，因此直接返回 alse。
计算整个数组的元素和 sum，如果sum 是奇数，则不可能将数组分割成元素和相等的两个子集，因此直接返回 false。如果 sum 是偶数，则令 target= sum/2
需要判断是否可以从数组中选出一些数字，使得这些数字的和等于 target。如果数组中最大元素maxNum>target，则除了 maxNum 以外的所有元素之和一定小于 target，因此不可能将数组分割成元素和相等的两个子集，直接返回 false。

dp数组的含义： dp数组有 n 行 target+1 列，其中 dp[i][j] 表示从数组的 [0,i] 下标范围内选取若干个正整数（可以是 0 个），是否存在一种选取方案使得被选取的正整数的和等于 j。

**边界条件：**初始时，dp 中的全部元素都是 false。

当 j==0 时，即不选取任何正整数，则被选取的正整数等于 0。因此对于所有 0≤i<n，都有 dp[i][0]=true。
当 i==0 时，只有一个正整数 nums[0] 可以被选取，因此 dp[0][nums[0]]=true。

状态转移方程：

当 i>0 && j>0 时：
- 如果 j≥nums[i]，则对于当前的数字 nums[i]，可以选取也可以不选取，两种情况只要有一个为 true，就有 dp[i][j]=true。
  - 如果不选取 nums[i]，则 dp[i][j]=dp[i−1][j]；
  - 如果选取 nums[i]，则 dp[i][j]=dp[i−1][j−nums[i]]。
- 如果 j<nums[i]，无法选取当前的数字 nums[i]，因此有 dp[i][j]=dp[i−1][j]。

$\begin{cases} dp[i−1][j] ∣ dp[i−1][j−nums[i]], & j≥nums[i] \\ dp[i−1][j], & j<nums[i] \end{cases}$

最终得到 dp[n−1][target] 即为答案。

class Solution {
    public boolean canPartition(int[] nums) {
        int n = nums.length;
        if (n < 2) {
            return false;
        }

        int sum = 0, maxNum = 0;
        for (int num : nums) {
            sum += num;
            maxNum = Math.max(maxNum, num);
        }
        if (sum % 2 != 0) {
            return false;
        }
        int target = sum / 2;
        if (maxNum > target) {
            return false;
        }
        
        boolean[][] dp = new boolean[n][target + 1];
        for (int i = 0; i < n; i++) {
            dp[i][0] = true;
        }
        dp[0][nums[0]] = true;
        for (int i = 1; i < n; i++) {
            int num = nums[i];
            for (int j = 1; j <= target; j++) {
                if (j >= num) {
                    dp[i][j] = dp[i - 1][j] | dp[i - 1][j - num];
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        return dp[n - 1][target];
    }
}

上述代码的空间复杂度是 O(n×target)，计算 dp 的过程中，每一行的 dp 值都只与上一行的 dp 值有关，因此只需要一个一维数组即可将空间复杂度降到 O(target)。此时的转移方程为：

$d p [j] = d p [j] ∣ d p [j - n u m s [i]]$

且需要注意的是第二层的循环我们需要从大到小计算，因为如果我们从小到大更新 dp 值，那么在计算 dp[j] 值的时候，dp[j−nums[i]] 已经是被更新过的状态，不再是上一行的 dp 值。

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