[leetcode-416-Partition Equal Subset Sum]

Given a non-empty array containing only positive integers, find if the array can be partitioned into two subsets such that the sum of elements in both subsets is equal.

Note:

1. Each of the array element will not exceed 100.
2. The array size will not exceed 200.

 

Example 1:

Input: [1, 5, 11, 5]

Output: true

Explanation: The array can be partitioned as [1, 5, 5] and [11].

 

Example 2:

Input: [1, 2, 3, 5]

Output: false

Explanation: The array cannot be partitioned into equal sum subsets.

思路：
类似于[leetcode-494-Target Sum]

想办法找到其中是否存在某几个元素的和为所有元素和的一半。使用回溯法查找。

却超时了。

void Par(bool& flag, vector<int>&nums, int target,int& temp,int begin)
     {
         if (temp == target)
         {
             flag = true;
             return;
         }
         for (int i = begin; i < nums.size(); i++)
         {
             if (!flag)
             {
                 temp += nums[i];
                 if(temp<=target)dfsPar(flag, nums, target, temp, i + 1);
                 temp -= nums[i];
             }             
         }
     }
     bool canPartition(vector<int>& nums)
     {
         bool flag = false;
         int sum = 0;
         if (nums.size() == 1)return false;
         for (int n : nums)sum += n;
         if (sum & 1)return false;
         int tempsum = 0;
         Par(flag, nums, sum >> 1, tempsum,0);
         return flag;
     }

 

想到了dp。我们定义一个一维的dp数组，其中dp[i]表示数字i是否是原数组的任意个子集合之和，那么我们我们最后只需要返回dp[target]就行了。我们初始化dp[0]为true，由于题目中限制了所有数字为正数，那么我们就不用担心会出现和为0或者负数的情况。那么关键问题就是要找出递归公式了，我们需要遍历原数组中的数字，对于遍历到的每个数字nums[i]，我们需要更新我们的dp数组，要更新[nums[i], target]之间的值，那么对于这个区间中的任意一个数字j，如果dp[j - nums[i]]为true的话，那么dp[j]就一定为true，于是地推公式如下：

dp[j] = dp[j] || dp[j - nums[i]]         (nums[i] <= j <= target)

有了递推公式，那么我们就可以写出代码如下：

bool canPartition(vector<int>& nums)
     {         
         int sum = 0;
         if (nums.size() == 1)return false;
         for (int n : nums)sum += n;
         if (sum & 1)return false;
         sum = sum >> 1;//除以2
         vector<int> dp(sum + 1,0);//dp[i]代表和为i的可能输
         dp[0] = 1;
         for (int i = 0; i < nums.size();i++)
         {
             for (int j = sum; j >= i;j--)
             {
                 dp[j] = dp[j] || dp[j - nums[i]];
             }
         }
         return dp[sum];
     }

 

 

参考了[leetcode-494-Target Sum]的dp解法，以及

https://discuss.leetcode.com/topic/62285/concise-c-solution-summary-with-dfs-dp-bit

http://www.cnblogs.com/grandyang/p/5951422.html。