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:

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.

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];
    }
};