kschappell/codetutor
Public Access
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

questions M-R

Browse Source
This commit is contained in:
Kai Chappell
2025-05-25 12:43:25 +01:00
parent 5dbe52df0d
commit ddceeec07e
62 changed files with 12841 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

217
backend/data/questions/partition-to-k-equal-sum-subsets.yaml Normal file
View File

@@ -0,0 +1,217 @@
title: Partition to K Equal Sum Subsets
slug: partition-to-k-equal-sum-subsets
difficulty: medium
leetcode_id: 698
leetcode_url: https://leetcode.com/problems/partition-to-k-equal-sum-subsets/
categories:
- arrays
- dynamic-programming
- recursion
patterns:
- backtracking
description: |
Given an integer array `nums` and an integer `k`, return `true` if it is possible to divide this array into `k` non-empty subsets whose sums are all equal.
constraints: |
- `1 <= k <= nums.length <= 16`
- `1 <= nums[i] <= 10^4`
- The frequency of each element is in the range `[1, 4]`
examples:
- input: "nums = [4,3,2,3,5,2,1], k = 4"
output: "true"
explanation: "It is possible to divide it into 4 subsets (5), (1,4), (2,3), (2,3) with equal sums of 5 each."
- input: "nums = [1,2,3,4], k = 3"
output: "false"
explanation: "The total sum is 10, which is not divisible by 3, so equal partition is impossible."
explanation:
intuition: |
Imagine you have `k` empty buckets, and each bucket must hold exactly the same total weight. Your task is to distribute all the items (numbers) from the array into these buckets such that every bucket ends up with the same sum.
The first insight is mathematical: if we can partition the array into `k` equal-sum subsets, then each subset must have sum equal to `total_sum / k`. If the total sum isn't divisible by `k`, we can immediately return `false`.
Think of it like this: you're trying to fill `k` buckets one by one. For each number, you try placing it in a bucket. If a bucket would overflow (exceed the target sum), you skip it. If you successfully fill all buckets to exactly the target, you've found a valid partition.
The key constraint `nums.length <= 16` is a hint — this small size allows exponential-time solutions like backtracking. The challenge is to prune the search space efficiently to avoid exploring redundant paths.
approach: |
We solve this using **Backtracking with Pruning**:
**Step 1: Early validation**
- Calculate `total_sum` of all elements
- If `total_sum % k != 0`, return `false` immediately — equal partition is impossible
- Calculate `target = total_sum / k` — this is the sum each bucket must have
- If any single element exceeds `target`, return `false` — it can't fit in any bucket
&nbsp;
**Step 2: Sort in descending order**
- Sort `nums` in descending order
- This crucial optimisation places larger numbers first, failing faster when a bucket can't fit
- Large numbers have fewer placement options, so trying them early prunes more branches
&nbsp;
**Step 3: Backtracking with k buckets**
- Create an array `buckets` of size `k`, all initialised to `0`
- For each number (in descending order), try placing it in each bucket
- A number can go in bucket `i` if `buckets[i] + num <= target`
- If placement succeeds, recursively try to place the next number
- If all numbers are placed successfully, return `true`
- If no valid placement exists, backtrack (remove number from bucket) and try the next bucket
&nbsp;
**Step 4: Skip duplicate buckets**
- If `buckets[i] == buckets[i-1]`, skip bucket `i` — placing the number there would lead to the same configuration we'll explore via bucket `i-1`
- This avoids redundant work when buckets have identical current sums
&nbsp;
**Step 5: Return the result**
- If backtracking explores all options without success, return `false`
common_pitfalls:
- title: Missing the Divisibility Check
description: |
If `total_sum % k != 0`, it's mathematically impossible to partition into `k` equal subsets. Always check this first to avoid unnecessary computation.
For example, `nums = [1,2,3,4]` with `k = 3` has sum `10`, which isn't divisible by `3`.
wrong_approach: "Starting backtracking without checking divisibility"
correct_approach: "Return false immediately if total_sum % k != 0"
- title: Not Sorting in Descending Order
description: |
Without sorting, the backtracking explores many dead-end paths before failing. By placing larger numbers first, we fail faster when a number can't fit.
Consider `nums = [1,1,1,1,1,1,10]` with `k = 2` and `target = 8`. Without sorting, we might try many combinations of 1s before realising the `10` can never fit. Sorting puts `10` first, causing immediate failure.
wrong_approach: "Backtracking on unsorted array"
correct_approach: "Sort descending to prune earlier"
- title: Not Skipping Duplicate Bucket States
description: |
If two buckets have the same current sum, placing a number in either leads to equivalent configurations. Without this optimisation, the algorithm does redundant work.
For example, with `buckets = [3, 3, 0, 0]` and trying to place `2`, placing it in bucket 0 vs bucket 1 creates the same branching structure. Skip one to avoid duplication.
wrong_approach: "Trying every bucket regardless of current sums"
correct_approach: "Skip bucket i if buckets[i] == buckets[i-1]"
- title: Forgetting the Single Large Element Check
description: |
If any element is larger than `target`, it can never fit in any bucket. Check this after calculating the target to fail fast.
wrong_approach: "Letting backtracking discover this through exhaustion"
correct_approach: "Check max(nums) <= target before backtracking"
key_takeaways:
- "**Backtracking pattern**: When exploring combinations, try each option, recurse, then undo (backtrack) if it doesn't lead to a solution"
- "**Pruning is essential**: Sorting descending and skipping duplicate states transform an unusable algorithm into a practical one"
- "**Mathematical pre-checks**: Always validate constraints (divisibility, max element) before starting expensive computation"
- "**Small constraints hint at approach**: `n <= 16` suggests exponential algorithms like backtracking or bitmask DP are acceptable"
time_complexity: "O(k * 2^n). In the worst case, we explore all possible subsets for each of the k buckets. Pruning significantly reduces this in practice."
space_complexity: "O(n). We use O(n) for the recursion stack depth and O(k) for the buckets array."
solutions:
- approach_name: Backtracking with Pruning
is_optimal: true
code: |
def can_partition_k_subsets(nums: list[int], k: int) -> bool:
total = sum(nums)
# If total isn't divisible by k, equal partition is impossible
if total % k != 0:
return False
target = total // k
# If any element exceeds target, it can't fit in any bucket
if max(nums) > target:
return False
# Sort descending to fail faster (large numbers have fewer options)
nums.sort(reverse=True)
# k buckets, each starting empty
buckets = [0] * k
def backtrack(index: int) -> bool:
# All numbers placed successfully
if index == len(nums):
return True
num = nums[index]
for i in range(k):
# Skip duplicate bucket states to avoid redundant work
if i > 0 and buckets[i] == buckets[i - 1]:
continue
# Try placing num in bucket i
if buckets[i] + num <= target:
buckets[i] += num
# Recurse to place next number
if backtrack(index + 1):
return True
# Backtrack: remove num from bucket
buckets[i] -= num
# No valid placement found for this number
return False
return backtrack(0)
explanation: |
**Time Complexity:** O(k * 2^n) worst case — we may explore all subset combinations. Pruning makes this much faster in practice.
**Space Complexity:** O(n) — recursion stack depth plus O(k) for buckets array.
We try to fill k buckets by placing each number (largest first) into a valid bucket. Key optimisations: sorting descending to fail fast, skipping duplicate bucket states to avoid redundant paths, and early termination checks.
- approach_name: Bitmask Dynamic Programming
is_optimal: false
code: |
def can_partition_k_subsets(nums: list[int], k: int) -> bool:
total = sum(nums)
if total % k != 0:
return False
target = total // k
n = len(nums)
# dp[mask] = remaining sum needed for current bucket
# -1 means this state is unreachable
dp = [-1] * (1 << n)
dp[0] = 0 # Empty set has 0 sum
for mask in range(1 << n):
if dp[mask] == -1:
continue
for i in range(n):
# If element i is not yet used
if mask & (1 << i) == 0:
# Current bucket sum after adding nums[i]
new_sum = dp[mask] + nums[i]
if new_sum <= target:
new_mask = mask | (1 << i)
# Mod by target: when bucket fills, start new one
dp[new_mask] = new_sum % target
# All elements used, last bucket exactly filled
return dp[(1 << n) - 1] == 0
explanation: |
**Time Complexity:** O(n * 2^n) — we iterate through all 2^n subsets and for each check n elements.
**Space Complexity:** O(2^n) — the dp array stores state for each possible subset.
This approach uses bitmask DP where each bit represents whether an element is used. We track the "remaining space" in the current bucket. When a bucket fills (`sum == target`), we start fresh with the next bucket (achieved via `% target`). This guarantees we consider all valid partitions systematically.