Leetcode:416. Partition Equal Subset Sum

题目大意是能不能把一个数组分成和相等的两部分。

首先我想到的是回溯，但是最后时间超了：

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = accumulate(nums.begin(), nums.end(), 0);
        if (sum % 2)
            return false;
        sort(nums.begin(), nums.end());
        if (nums.back() > sum / 2)
            return false;
        if (nums.back() == sum / 2)
            return true;
        
        return backtrack(nums, 0, 0, sum/2);
    }
private:
    bool backtrack(const vector<int>& nums, int index, int tempSum, int target) {
        if (tempSum == target)
            return true;
        else if (tempSum > target) 
            return false;
        else {
            for (int i = index; i < nums.size(); ++i) {
                tempSum += nums[i];
                if (backtrack(nums, i+1, tempSum, target))
                    return true;
                tempSum -= nums[i];
            }
            return false;
        }
    }
};

然后看了讨论区，才发现应该使用0/1背包的思想去做这道题。
0/1背包思想在我看来是这样：给你一堆东西，对于其中每一个，为了完成目标，你讨论选或者不选它。
对于这题，我们设dp[i][j]:对于前i个数，能找出数组成数j吗？
如果nums[i] > j ，则dp[i][j] = dp[i-1][j]
否则,dp[i][j] = dp[i-1][j] || dp[i-1][j-nums[i]]
代码：

class Solution {//回溯法可以，但是太慢
public:
    bool canPartition(vector<int>& nums) {
        int sum = accumulate(nums.begin(), nums.end(), 0);
        if (sum % 2)
            return false;
        sort(nums.begin(), nums.end());
        if (nums.back() > sum / 2)
            return false;
        if (nums.back() == sum / 2)
            return true;
        
        vector<vector<bool>> dp(nums.size(), vector<bool>(sum/2+1, false));//这儿必须得加一，比如目标是6，那么大小得为7
        int rows = dp.size(), cols = dp[0].size();
        for (int i = 0; i < rows; ++i)
            dp[i][0] = true;
        for (int j = 1; j < cols; ++j)
            dp[0][j] = false;
        if (nums[0] < cols)
            dp[0][nums[0]] = true;
        for (int i = 1; i < rows; ++i)
            for (int j = 1; j < cols; ++j) {
                if (nums[i] > j)
                    dp[i][j] = dp[i-1][j];
                else
                    dp[i][j] = dp[i-1][j] || dp[i-1][j - nums[i]];
            }
        
        return dp.back().back();
    }
};

更新：回溯是可以的，不过需要进行优化，见最新的博文