Partition Equal Subset Sum

Partition Equal Subset Sum - Problem

Given an integer array nums, return true if you can partition the array into two subsets such that the sum of the elements in both subsets is equal, or false otherwise.

Key Points:

Each element can only be used once
Both subsets must contain at least one element
The order of elements within subsets doesn't matter

Input & Output

Example 1 — Basic Partition

$ Input: nums = [1,5,11,5]

› Output: true

💡 Note: Array can be partitioned as [1,5,5] and [11]. Both subsets have sum = 11.

Example 2 — Cannot Partition

$ Input: nums = [1,2,3,5]

› Output: false

💡 Note: Total sum = 11 (odd), so cannot be split into two equal subsets.

Example 3 — Minimum Case

$ Input: nums = [1,1]

› Output: true

💡 Note: Can partition as [1] and [1]. Both subsets have sum = 1.

Constraints

1 ≤ nums.length ≤ 200
1 ≤ nums[i] ≤ 100

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 38 f Facebook 32 M Microsoft 28

The key insight is that we only need to find if one subset with sum = total/2 exists, as the remaining elements automatically form the other subset. The optimal 1D DP approach tracks achievable sums efficiently. Time: O(n × sum), Space: O(sum).

Common Approaches

✓ 1D Dynamic Programming

⏱️ Time: O(n × sum) Space: O(sum)

Create a DP array where dp[i] represents whether sum i is achievable. For each element, update the DP array backwards to avoid using the same element twice in one iteration.

Backtracking with Pruning

⏱️ Time: O(2^n) Space: O(n)

Recursively try including or excluding each element. If current sum equals target, return true. If sum exceeds target, backtrack immediately to avoid unnecessary exploration.

Brute Force - Try All Subsets

⏱️ Time: O(2^n) Space: O(1)

Use bit manipulation or recursion to generate all 2^n possible subsets. For each subset, calculate its sum and check if it equals half the total sum. If found, return true.

Memoization (Top-Down DP)

⏱️ Time: O(n × sum) Space: O(n × sum)

Similar to backtracking but cache results for each (index, current_sum) pair. This eliminates redundant calculations when the same state is reached through different paths.

1D Dynamic Programming — Algorithm Steps

Check if total sum is even, return false if not
Initialize DP array with dp[0] = true
For each number, update DP array backwards to mark achievable sums

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[0] = true (empty subset sum = 0)

Process Elements

For each element, update achievable sums backwards

Check Target

Return dp[target] to see if target sum is achievable

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

int solution(int* nums, int numsSize) {
    int total = 0;
    for (int i = 0; i < numsSize; i++) {
        total += nums[i];
    }
    
    if (total % 2 != 0) {
        return 0;
    }
    
    int target = total / 2;
    bool* dp = (bool*)calloc(target + 1, sizeof(bool));
    dp[0] = true;  // Sum of 0 is always achievable with empty subset
    
    for (int i = 0; i < numsSize; i++) {
        // Iterate backwards to avoid using same element twice
        for (int j = target; j >= nums[i]; j--) {
            dp[j] = dp[j] || dp[j - nums[i]];
        }
    }
    
    bool result = dp[target];
    free(dp);
    return result ? 1 : 0;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[200];
    int numsSize = 0;
    
    char* ptr = line + 1; // Skip '['
    char* token = strtok(ptr, ",]");
    
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, numsSize);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × sum)

For each of n elements, iterate through sums up to total/2

✓ Linear Growth

Space Complexity

O(sum)

DP array of size sum/2 to track achievable sums

✓ Linear Space

185.0K Views

High Frequency

~25 min Avg. Time

8.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

1D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler