[LC] 416. Partition Equal Subset Sum

这题是0-1背包问题的变种，类似的还有另一题是完全背包问题是https://blog.csdn.net/chaochen1407/article/details/90767890 。当初没认出来它其实是一个完全背包问题。主要是自己对背包问题也没有很好的学习过。

这题需要一定的转换才能看成是一个背包问题。它题意的意思是可以把这个array变成两个不重叠的部分，两个部分的和是一样的。所以，任意一边的和，其实是所有数字的和的一半。这就变成了另一个题目：如何找到一个subset，它们的和是指定的数字，而这一题的指定的数字，就是总和的一半。

一个很naive的想法可以是暴力递归遍历。就是每个数字选和不选的情况都遍历一下。最后的算法复杂度便会是2的n次方，n是数组的长度。这个比较容易我就不写了。

而从背包问题的角度考虑，就是从拿一个数字，到拿n个数字看，是否能够求和到总和的一半。状态转换方程如下

f(i, j) = f(i - 1, j) OR f(i - 1, j - nums[i]) （在这里我们假设nums这个数字是1-based index的） 

这个方程的意思是这样子的，其中i表示的是从nums这个数组里面取多少个数字，j表示的是当前总和。f(i, j)的意思是，在i个数字里面，是否存在一个子集它的和等于j。所以最后要返回的答案就是f(nums.length, target)，target就是所有数字总和的一半。
而整个表达式的意思就是取前i个数字里，是否存在一个子集的和能够达到 j。两种情况满足
1. f(i - 1, j)如果为true，f(i,j)也为true，理由很简单，前面i - 1个数字都存在子集满足了，我多放一个数字也没变啊。
2. f(i - 1, j - nums[i])如果为true， f(i, j)也为true，也就是如果前面i - 1个数字存在子集的和为j - nums[i]，那么这个子集加上nums[i]的和就是j。所以f(i, j)也成立。

遍历的方式，就是从1 ... nums.length，以及1 ... target的二维循环做起。

根据上述解释，可以得到代码如下：

    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int num : nums) sum+= num;
        //总和都不能被2整除，你怎么能够分成两份subset
        if (sum % 2 == 1) return false;
        int target = sum / 2;
        
        boolean[][] dp = new boolean[nums.length + 1][target + 1];
        for (int i = 0; i <= nums.length; i++) {
            // 这个意思就是取i个数，是否有SUBSET能组成0
            // 答案是当然可以，因为不管取多少个数，空集的和都是0
            dp[i][0] = true;
        }
        
        for (int i = 1; i <= target; i++) {
            // 这个意思是，取0个数，都不可能SUM UP到0以外的数字
            dp[0][i] = false;
        }
        
        // 开始正式的DP遍历，逻辑是取1，2，3...nums.length这么多个数，有没有子集可以求和出
        // 1,2,3...target
        for (int i = 1; i <= nums.length; i++) {
            for (int j = 1; j <= target; j++) {
                //如果前i - 1个数的子集能sum up到j, 那第i个数肯定也可以
                dp[i][j] = dp[i - 1][j];
                if (j >= nums[i - 1]) {
                    //如果前i - 1个数的子集能达到 j - nums[i - 1]
                    //那么如今我们加上nums[i - 1]，肯定也能到达j。
                    dp[i][j] = dp[i][j] || dp[i - 1][j - nums[i - 1]];
                }
            }
        }
        
        return dp[nums.length][target];
    }

因为这个DP中，关于取前面i个数字的状态只和取前面i - 1个数字的状态有所关联。所以两维的存储空间可以优化成一维。但需要把内部循环TARGET的for loop改成逆序。否则上一层的状态会被覆盖。这和背包九讲的第一讲中的优化概念是类似的：https://www.kancloud.cn/kancloud/pack/70125

改成一维之后的代码如下:

    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int num : nums) sum+= num;
        //总和都不能被2整除，你怎么能够分成两份subset
        if (sum % 2 == 1) return false;
        int target = sum / 2;
        
        boolean[] dp = new boolean[target + 1];
        dp[0] = true;

        for (int i = 0; i < nums.length; i++) {
            //这里逆序是为了计算过程中不能覆盖上一层的状态，所以要从高数值到低数值覆盖
            for (int j = target; j >= nums[i]; j--) {
                dp[j] |= dp[j - nums[i]];
            }
        }
        
        return dp[target];
    }