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.

 Idea 1. Subset sum

[1, 5, 11, 5]

containing 1: [1], sum {1}

containing 5: [5], [1, 5]   sum {5, 6}

containing 11: [11], [1, 11], [5, 11], [1, 5, 11]  {11, 12, 16, 17}

containing: 5: [5], [1, 5], [5, 5], [1, 5, 5], [11, 5], [1, 11, 5], [5, 11, 5], [1, 5, 11, 5], {5, 6, 10, 11, 16, 17, 21, 22}

Time complexity: O(2^n -1)

Space complexity: O(2^n -1)

class Solution {
    public boolean canPartition(int[] nums) {
        int totalSum = 0;
        for(int num: nums) {
            totalSum += num;
        }
        if(totalSum%2 != 0) {
            return false;
        }
        
        List<List<Integer>> endSum = new ArrayList<>();
        for(int i = 0; i < nums.length; ++i) {
            List<Integer> curr = new ArrayList<>();
            if(nums[i] == totalSum/2) {
                return true;
            }
            curr.add(nums[i]);
            for(int j = 0; j < i; ++j) {
                for(int val: endSum.get(j)) {
                    int currSum = val + nums[i];
                    if(currSum == totalSum/2) {
                        return true;
                    }
                    curr.add(currSum);
                }
            }
            endSum.add(curr);
        }
        return false;
    }
}

Idea 2: dynamic programming. Let dp[i][j] represents if the subset sum from num[0..i] could reach j, 

dp[i][j] = dp[i-1][j] not picking nums[i], 

　　　　dp[i-1][j-nums[i]] picking nums[i]

Note. to initialise dp[-1][0] = 0

Time complexity: O(n*target)

Space complexity: O(n*target)

class Solution {
    private void backtrack(int[] nums, int i, boolean[][] dp, int target) {
        if(i > nums.length) {
            return;
        }
        
        for(int j = 1; j <= target; ++j) {
            dp[i][j] = dp[i-1][j];
            if(j >= nums[i-1]) {
                dp[i][j] = dp[i][j] || dp[i-1][j-nums[i-1]];
            }
        }
        backtrack(nums, i+1, dp, target);
    }
    
    public boolean canPartition(int[] nums) {
        int totalSum = 0;
        for(int num: nums) {
            totalSum += num;
        }
        
        if(totalSum %2 != 0) {
            return false;
        }
        int n = nums.length;
        int target = totalSum/2;
        boolean[][] dp = new boolean[n+1][target+1];
        for(int i = 0; i <= n; ++i) {
            dp[i][0] = true;
        }
        
        backtrack(nums, 1, dp, target);
        return dp[n][target];
    }
}

class Solution {
    public boolean canPartition(int[] nums) {
       int totalSum = 0;
       for(int num: nums) {
           totalSum += num;
       }
        
       if(totalSum %2 != 0) {
           return false;
       }
        
       int target = totalSum/2;
       int m = nums.length;
       boolean[][] dp = new boolean[m+1][target+1];
       dp[0][0] = true;
        
       for(int i = 1; i <= m; ++i) {
           for(int j = 1; j <= target; ++j) {
               dp[i][j] = dp[i-1][j];
               if(j >= nums[i-1]) {
                   dp[i][j] = dp[i][j] || dp[i-1][j-nums[i-1]];
               }
           }
       }
        
       return dp[m][target];
    }
}

Idea 2. dynamic programming, 二维到一维的优化，注意在二维公式中sum的循环是从小到大（从左到右)，但是是前一行，转换成一维,需要用到前边的状态，所以要从右向左

 dp[j] = dp[j] || dp[j-nums[i]]

dp[0] = true

Time complexity: O(n*target)

Space complexity: O(target)

class Solution {
    public boolean canPartition(int[] nums) {
      int totalSum = 0;
        
      for(int num: nums) {
          totalSum += num;
      }
        
      if(totalSum % 2 != 0) {
          return false;
      }
        
      int target = totalSum/2;
      int n = nums.length;
      boolean[] dp = new boolean[target+1];
      dp[0] = true;
        
      for(int i = 0; i < n; ++i) {
          for(int j = target; j >= nums[i]; --j) {
              dp[j] = dp[j] || dp[j-nums[i]];
          }
      }
    
      return dp[target];
    }
}