Leetcode416. 分割等和子集

题目：
给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

示例 1：

输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。
1
2
3

示例 2：

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

题解：
动态规划：

1. 数组长度$n<2$,返回false;
2. 数组所有元素和$\text{sum}$以及最大元素 $\text{maxNum}$ ,如果$\text{sum}$是奇数，返回false;
3. 如果$\text{sum}$是偶数，$\text{target}=\frac{\text{sum}}{2}$,需要判断是否可以从数组中选出一些数字，使得这些数字的和等于 $\text{target}$,如果 $\text{maxNum}>\text{target}$，则除了$\text{maxNum}$ 以外的所有元素之和一定小于 $\text{target}$，因此不可能将数组分割成元素和相等的两个子集，直接返回false;

创建二维数组 $\text{dp}$，包含 $n$ 行 $\text{target}+1$列，其中 $\text{dp}[i][j]$ 表示从数组的 $[0,i]$ 下标范围内选取若干个正整数（可以是 0 个），是否存在一种选取方案使得被选取的正整数的和等于 $j$。初始时，$\text{dp}$ 中的全部元素都是 $\text{false}$。

在定义状态之后，需要考虑边界情况。以下两种情况都属于边界情况。

• 如果不选取任何正整数，则被选取的正整数等于 0。因此对于所有 $0\le i$ < n，都有$\text{dp}[i][0]=\text{true}$。
• 当 $i=0$ 时，只有一个正整数 $\text{nums}[0]$ 可以被选取，因此$\text{dp}[0][\text{nums}[0]]=\text{true}$。

对于$i>0$ 且 $j>0$ 的情况，如何确定 $\text{dp}[i][j]$ 的值？需要分别考虑以下两种情况。

如果 $j\ge \text{nums}[i]$，则对于当前的数字 $nums[i]$，可以选取也可以不选取，两种情况只要有一个为 $true$，就有 $\text{dp}[i][j]=\text{true}$。

• 如果不选取 $\text{nums}[i]$，则$\text{dp}[i][j]=\text{dp}[i-1][j]$；

• 如果选取$nums[i]$，则$\text{dp}[i][j]=\text{dp}[i-1][j-\text{nums}[i]]$。

如果 $j<\text{nums}[i]$，则在选取的数字的和等于 $j$ 的情况下无法选取当前的数字$nums[i]$，因此有
$\text{dp}[i][j]=\text{dp}[i-1][j]$。

状态转移方程如下：

$\text{dp}[i][j]=\{\begin{array}{ll}\text{dp}[i-1][j]|\text{dp}[i-1][j-\text{nums}[i]],& j\ge \text{nums}[i]\\ \text{dp}[i-1][j],& j<\text{nums}[i]\end{array}$

最终得到 $\text{dp}[n-1][\text{target}]$即为答案。

java代码：

    public boolean canPartition(int[] nums) {
        int n = nums.length;
        if (n < 2) return false;
        int sum = 0;
        int maxValue = 0;
        for (int num : nums) {
            sum += num;
            maxValue = Math.max(maxValue, num);
        }
        //总和是奇数
        if (sum % 2 != 0) {
            return false;
        }
        //最大值超过总和的一半
        int target = sum / 2;
        if (maxValue > target) {
            return false;
        }
        // dp[i][j] : 从[0,i]中选取nums中的若干个正整数使得和为j
        boolean[][] dp = new boolean[n][target + 1];
        for (int i = 0; i < n; i++) {
            //从[0,i]中不选任何正整数
            dp[i][0] = true;
        }
        //i=0时，只有一个正数nums[0]可以被选取
        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];
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40