416. Partition Equal Subset Sum

Problem statement:

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:

Each of the array element will not exceed 100.

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.

Solution: DFS with return value(TLE).

This problem can be solved by DFS with or without a return value. I choose a the DFS template with a bool return value. It returns true once we find a subset.

Before the DFS, I sort the array in ascending order first.

In each DFS level, ignore the duplicated value.

cur_sum < 0 ---> return false.

cur_sum == 0 ---> return true;

cur_sum > 0 ---> continue on DFS search.

However, it is a TLE solution, can not pass OJ.

Since there are two situations for each element: selected or not. Time complexity is O(2^n).

class Solution {
public:
bool canPartition(vector<int>& nums) {
sort(nums.begin(), nums.end());
int sum = accumulate(nums.begin(), nums.end(), 0);
return !(sum & 1) && can_partition_dfs(nums, sum / 2, 0);
}
bool can_partition_dfs(vector<int>& nums, int cur_sum, int idx){
if(cur_sum < 0){
return cur_sum == 0;
}
int can_partition = false;
for(int i = idx; i < nums.size(); i++){
can_partition |= can_partition_dfs(nums, cur_sum - nums[i], i + 1);
while(i + 1 < nums.size() && nums[i] == nums[i + 1]){
i++;
}
}
return can_partition;
}
};

Solution two: knapsack problem dynamic programming(AC)

This problem can be solved by a knapsack model with a dynamic programming philosophy.

dp[i][j]: means first i element could form a summation to j

Time complexity is O(m * sum). Space complexity is O(m * sum).

class Solution {
public:
bool canPartition(vector<int>& nums) {
int total_sum = accumulate(nums.begin(), nums.end(), 0);
if(total_sum % 2){
return false;
}
int size = nums.size();
int sum = total_sum / 2;
// dp[i][sum]: first i elements could form a summation to sum or not
vector<vector<bool>> dp(size + 1, vector<bool>(sum + 1, false));
// initialization
for(int i = 0; i <= size; i++){
dp[i][0] = true;
}
for (int i = 1; i <= size; i++) {
for (int j = 1; j <= sum; j++) {
if (j >= nums[i - 1] && dp[i - 1][j - nums[i - 1]]){
dp[i][j] = true;
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
return dp[size][sum];
}
};

We can optimize the space complexity to O(sum).

class Solution {
public:
bool canPartition(vector<int>& nums) {
int total_sum = accumulate(nums.begin(), nums.end(), 0);
if(total_sum % 2){
return false;
}
int size = nums.size();
int sum = total_sum / 2;
vector<bool> dp(sum + 1, false);
dp[0] = true;
for(auto num : nums){
for(int j = sum; j >= num; j--){
dp[j] = dp[j] || dp[j - num];
}
}
return dp[sum];
}
};