Partition Equal Subset Sum - Practice Coding Problems

Partition Equal Subset Sum - Problem

Given an integer array nums, determine if you can partition the array into two subsets such that the sum of elements in both subsets is exactly equal.

This is a classic problem that tests your understanding of dynamic programming and subset sum concepts. The key insight is that if we can partition an array into two equal subsets, then each subset must have a sum equal to total_sum / 2.

Goal: Return true if such a partition exists, false otherwise.

Example: For array [1, 5, 11, 5], we can partition it into [1, 5, 5] and [11], both having sum = 11.

Input & Output

example_1.py — Equal Partition Possible

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

› Output: true

💡 Note: The array can be partitioned as [1, 5, 5] and [11], both subsets have sum = 11

example_2.py — No Equal Partition

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

› Output: false

💡 Note: Total sum is 11 (odd), so it's impossible to partition into two equal subsets

example_3.py — Single Element

$ Input: nums = [1]

› Output: false

💡 Note: Cannot partition a single element into two non-empty equal subsets

Constraints

1 ≤ nums.length ≤ 200
1 ≤ nums[i] ≤ 100
All integers in nums are positive

Visualization

Tap to expand

Understanding the Visualization

Check Feasibility

If total sum is odd, return false immediately

Initialize DP

Create boolean array to track achievable sums, dp[0] = true

Process Each Element

For each element, update which new sums become possible

Return Result

Check if target sum (total/2) is achievable

Key Takeaway

🎯 Key Insight: Instead of generating all possible subsets (exponential), we use DP to track achievable sums in O(n × sum) time and O(sum) space!

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal approach uses 1D Dynamic Programming with space optimization. Instead of tracking all subset combinations, we only need to know which sums are achievable. The key insight is that if we can make sum = total/2, then the remaining elements automatically form the other half.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (2D Table)	O(n * sum)	O(n * sum)	Use 2D DP table to track which sums are achievable with each element
Brute Force (Generate All Subsets)	O(2^n)	O(n)	Generate all possible subsets and check if any has sum equal to total/2

Dynamic Programming (2D Table) — Algorithm Steps

Calculate total sum and check if it's even
Create 2D DP table dp[n+1][target+1]
Initialize base case: dp[0][0] = true (sum 0 with 0 elements)
For each element and each possible sum, decide include/exclude
Return dp[n][target]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Table

Create 2D table with base case dp[i][0] = true

Fill Table

For each element, decide whether to include it or not

Check Result

Final answer is dp[n][target]

Code -

solution.c — C

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

bool canPartition(int* nums, int numsSize) {
    int totalSum = 0;
    for (int i = 0; i < numsSize; i++) {
        totalSum += nums[i];
    }
    
    if (totalSum % 2 == 1) return false;
    
    int target = totalSum / 2;
    
    // Create 2D DP table
    bool** dp = (bool**)malloc((numsSize + 1) * sizeof(bool*));
    for (int i = 0; i <= numsSize; i++) {
        dp[i] = (bool*)calloc(target + 1, sizeof(bool));
        dp[i][0] = true; // Base case
    }
    
    // Fill the DP table
    for (int i = 1; i <= numsSize; i++) {
        for (int j = 1; j <= target; j++) {
            dp[i][j] = dp[i-1][j];
            if (nums[i-1] <= j) {
                dp[i][j] = dp[i][j] || dp[i-1][j-nums[i-1]];
            }
        }
    }
    
    bool result = dp[numsSize][target];
    
    // Free memory
    for (int i = 0; i <= numsSize; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    int nums[] = {1, 5, 11, 5};
    int size = sizeof(nums) / sizeof(nums[0]);
    printf("%s\n", canPartition(nums, size) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * sum)

We fill a table of size n × sum, each cell takes O(1) time

✓ Linear Growth

Space Complexity

O(n * sum)

2D DP table storing boolean values for each state

⚡ Linearithmic Space

58.3K Views

High Frequency

~25 min Avg. Time

1.8K 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

Dynamic Programming (2D Table) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler