416. Partition Equal Subset Sum [Medium]

最开始不会写，没有找到动态规划的思路，看了dp数组怎么设后写的以下所有代码

第二段代码为最优解

recursion + mem的一个小技巧：

mem是基本数据类型的数组，且不好根据值确定是否计算过的时候，可以用其对应的引用类型建立数组，这样null的就是没计算过的位置，如第三段代码

（第四段代码中没有必要，因为即使是计算过的位置，只要不是true，也要每次循环都更新，所以只有mem[sum]为true是直接返回，初始的false和计算过的false归为一种情况处理；而第三段代码中，已经计算过的位置都确定了）

// 0-1背包问题动态规划
class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int i : nums)
            sum += i;
        if ((sum & 1) == 1) // 奇数一定是false
            return false;
        sum /= 2; // 算出nums和的一半

        int n = nums.length;
        boolean[][] dp = new boolean[n + 1][sum + 1];
        dp[0][0] = true;
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j <= sum; j++) {
                if (dp[i - 1][j]) {
                    dp[i][j] = true;
                    continue;
                }
                if (j >= nums[i - 1])
                    dp[i][j] = dp[i - 1][j - nums[i - 1]];
            }
        }    
        return dp[n][sum];
    }
}

// 优化0-1背包问题动态规划解法的空间，dp数组从二维降至一维
class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int i : nums)
            sum += i;
        if (sum == 0 || (sum & 1) == 1)
            return false;
        sum /= 2;
        
        boolean[] dp = new boolean[sum + 1];
        dp[0] = true;
        for (int i : nums)
            for (int j = sum; j >= i; j--)
                if (!dp[j]) // 这两句也可以写成dp[j] = dp[j] || dp[j - i];
                    dp[j] = dp[j - i];
        return dp[sum];
    }
}

// recursion + 二维mem
class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int i : nums)
            sum += i;
        if (sum == 0 || (sum & 1) == 1)
            return false;
        sum /= 2;
        Boolean[][] mem = new Boolean[nums.length + 1][sum + 1]; // 用Boolean而非boolean是为了recursion时判断该位置是否被计算过
        return helper(nums, mem, nums.length, sum);
    }
    
    private boolean helper(int[] nums, Boolean[][] mem, int pos, int sum) {
        if (sum == 0)
            return true;
        if (pos == 0)
            return false;
        if (mem[pos][sum] != null)
            return mem[pos][sum];
        if (helper(nums, mem, pos - 1, sum)) // mem[pos-1][sum]为true，则mem[pos][sum]一定为true
            mem[pos][sum] = true;
        else if (sum >= nums[pos - 1]) // mem[pos-1][sum]为false，若sum>=nums[pos-1]，检查mem[pos-1][sum-nums[pos-1]]
            mem[pos][sum] = helper(nums, mem, pos - 1, sum - nums[pos - 1]);
        else // mem[pos-1][sum]为false，且sum<nums[pos-1]，则mem[pos][sum]一定为false
            mem[pos][sum] = false;
        return mem[pos][sum];
    }
}

/**
 * 失败的尝试，recursion + 一维mem
 * 逻辑没错，但会Time Limit Exceeded，因为有很多算过的结果没有存储，造成很多重复的计算
 */
class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int i : nums)
            sum += i;
        if (sum == 0 || (sum & 1) == 1)
            return false;
        sum /= 2;
        boolean[] mem = new boolean[sum + 1];
        return helper(nums, mem, nums.length - 1, sum);
    }
    
    private boolean helper(int[] nums, boolean[] mem, int pos, int sum) {
        if (sum == 0 || mem[sum])
            return true;
        for (int i = pos; i >= 0; i--)
            if (mem[sum])
                return true;
            else if (nums[i] <= sum)
                mem[sum] = helper(nums, mem, i - 1, sum - nums[i]);
        return mem[sum];
    }
}