Partition to K Equal Sum Subsets - Practice Coding Problems

Partition to K Equal Sum Subsets - Problem

Array Dynamic Programming Backtracking Bit Manipulation Memoization Bitmask Medium

Imagine you have a collection of numbered cards and want to distribute them into k equal-value piles. This is exactly what the Partition to K Equal Sum Subsets problem asks you to solve!

Given an integer array nums and an integer k, your task is to determine if it's possible to divide the array into k non-empty subsets where each subset has the exact same sum.

Key Requirements:

All k subsets must be non-empty
Every element must belong to exactly one subset
All subset sums must be equal

Example: If nums = [4,3,2,3,5,2,1] and k = 4, we can form 4 subsets: [5], [1,4], [2,3], [2,3] - each with sum 5!

Input & Output

example_1.py — Basic Partition

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

› Output: true

💡 Note: We can form 4 subsets with equal sum 5: [5], [1,4], [2,3], [2,3]. Each subset sums to 5.

example_2.py — Impossible Partition

$ Input: nums = [1,2,3,4], k = 3

› Output: false

💡 Note: Total sum is 10, which cannot be evenly divided into 3 subsets (10/3 is not an integer).

example_3.py — Single Element Subsets

$ Input: nums = [2,2,2,2,2,2], k = 3

› Output: true

💡 Note: We can form 3 subsets: [2,2], [2,2], [2,2]. Each subset has sum 4.

Visualization

Tap to expand

Understanding the Visualization

Check Feasibility

Verify total treasure can be divided equally among k crews

Sort by Value

Start with most valuable coins to fail fast if impossible

Distribute Recursively

Try assigning each coin to crews that can accommodate it

Prune Invalid Paths

Skip equivalent empty crews and impossible assignments

Key Takeaway

🎯 Key Insight: Sort elements in descending order and use backtracking with pruning to efficiently explore the solution space. Memoization with bitmasks can further optimize by avoiding redundant state calculations.

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

Worst case is still exponential, but pruning significantly reduces average case

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth plus array for subset sums

⚡ Linearithmic Space

Constraints

1 ≤ k ≤ nums.length ≤ 16
1 ≤ nums[i] ≤ 10⁴
Small input size allows for exponential algorithms

Asked in

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

The optimal approach uses backtracking with pruning and memoization. Key optimizations include sorting array in descending order, using bitmasks to represent states, and memoizing results to avoid redundant calculations. The algorithm achieves significant speedup over naive backtracking while guaranteeing the correct solution.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Backtracking with Pruning	O(k^n)	O(n)	Enhanced backtracking with sorting and intelligent pruning techniques

Optimized Backtracking with Pruning — Algorithm Steps

Sort array in descending order for better pruning
Check if sum is divisible by k and no element exceeds target
Use backtracking with multiple pruning strategies
Avoid trying equivalent empty subsets
Skip remaining subsets if current element doesn't fit anywhere

Visualization

Tap to expand

Step-by-Step Walkthrough

Bitmask State

Each bit represents if an element is used (1) or available (0)

Memoization Check

Check if we've computed result for this bitmask before

Try Next Element

Try adding available elements to current subset

Store Result

Memoize the result for this state to avoid future recomputation

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)b - *(int*)a);
}

bool backtrack(int* nums, int numsSize, int* subsets, int k, int index, int target) {
    if (index == numsSize) {
        for (int i = 0; i < k; i++) {
            if (subsets[i] != target) return false;
        }
        return true;
    }
    
    for (int i = 0; i < k; i++) {
        if (subsets[i] + nums[index] > target) continue;
        
        subsets[i] += nums[index];
        if (backtrack(nums, numsSize, subsets, k, index + 1, target)) {
            return true;
        }
        subsets[i] -= nums[index];
        
        if (subsets[i] == 0) break;
    }
    
    return false;
}

bool canPartitionKSubsets(int* nums, int numsSize, int k) {
    int total = 0;
    for (int i = 0; i < numsSize; i++) {
        total += nums[i];
    }
    
    if (total % k != 0) return false;
    
    int target = total / k;
    qsort(nums, numsSize, sizeof(int), compare);
    
    if (nums[0] > target) return false;
    
    int* subsets = (int*)calloc(k, sizeof(int));
    bool result = backtrack(nums, numsSize, subsets, k, 0, target);
    free(subsets);
    return result;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

Worst case is still exponential, but pruning significantly reduces average case

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth plus array for subset sums

⚡ Linearithmic Space

Constraints

1 ≤ k ≤ nums.length ≤ 16
1 ≤ nums[i] ≤ 10⁴
Small input size allows for exponential algorithms

127.8K Views

Medium-High Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Backtracking with Pruning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler