Combination Sum - Practice Coding Problems

Combination Sum - Problem

Array Backtracking Medium

The Combination Sum Challenge: Imagine you're a treasure hunter with a magical bag of coins of different denominations, and you need to find all possible ways to make exact change for a target amount. Here's the twist - your bag has unlimited coins of each denomination!

Given an array of candidates containing distinct positive integers and a target integer, your mission is to return all unique combinations of candidates where the chosen numbers sum to the target.

Key Rules:

🔄 You can use the same number multiple times
🎯 Each combination must sum exactly to the target
✨ Return combinations in any order
🔢 Two combinations are unique if they differ in frequency of at least one number

Example: With candidates [2,3,6,7] and target 7, you could make 7 using [7] or [2,2,3] - both are valid!

Input & Output

example_1.py — Basic Case

$ Input: candidates = [2,3,6,7], target = 7

› Output: [[2,2,3],[7]]

💡 Note: We can make 7 in two ways: using three coins [2,2,3] (2+2+3=7) or one coin [7]. Both combinations are unique and sum to the target.

example_2.py — Multiple Solutions

$ Input: candidates = [2,3,5], target = 8

› Output: [[2,2,2,2],[2,3,3],[3,5]]

💡 Note: Three different ways to make 8: four 2's (2+2+2+2=8), two 2's and two 3's (2+3+3=8), or one 3 and one 5 (3+5=8).

example_3.py — No Solution

$ Input: candidates = [2], target = 1

› Output: []

💡 Note: Cannot make target 1 using only candidate 2, since 2 > 1. No valid combinations exist.

Visualization

Tap to expand

Understanding the Visualization

Sort Your Coins

Arrange coins [2,3,6,7] in order so we can stop early when a coin is too big

Start Exploring

Begin with empty combination, try each coin type systematically

Smart Recursion

When using a coin, we can use it again (unlimited supply) or try larger coins

Early Stopping

If current coin > remaining target, skip it and all larger coins

Collect Solutions

When remaining target = 0, we found a valid combination!

Key Takeaway

🎯 Key Insight: Backtracking systematically explores the solution space while pruning impossible branches early, making it the perfect algorithm for finding all valid combinations efficiently.

Time & Space Complexity

Time Complexity

⏱️

O(N^(T/M))

Same worst case as brute force, but with significant practical improvements due to pruning

✓ Linear Growth

Space Complexity

O(T/M)

Space for recursion stack and storing results

✓ Linear Space

Constraints

1 ≤ candidates.length ≤ 30
2 ≤ candidates[i] ≤ 40
All elements of candidates are distinct
1 ≤ target ≤ 40
The number of unique combinations ≤ 150

Asked in

a Amazon 45 f Facebook 38 G Google 32 ⊞ Microsoft 28 Apple 22

The optimal approach uses backtracking with pruning to systematically explore all valid combinations. Key optimizations include sorting candidates for early termination, using a start index to avoid duplicate combinations, and pruning branches when remaining target becomes negative. This ensures we find all unique combinations efficiently without exploring impossible paths.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Backtracking (Optimal)	O(N^(T/M))	O(T/M)	Use backtracking with pruning and sorting to avoid duplicates efficiently
Brute Force (Generate All Combinations)	O(N^(T/M))	O(T/M)	Generate all possible combinations with repetition and filter valid ones

Optimized Backtracking (Optimal) — Algorithm Steps

Sort candidates array for early termination optimization
Use backtracking with a start index to avoid duplicate combinations
For each recursive call, only consider candidates from current index onwards
Terminate early when current candidate exceeds remaining target

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Candidates

Sort [2,3,6,7] for early termination

Use Start Index

Each recursion only considers candidates from current index onwards

Early Termination

Stop when candidate > remaining target

No Duplicates

Start index ensures we don't generate [2,3] and [3,2] separately

Code -

solution.c — C

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

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

int** result;
int* resultSize;
int** columnSizes;
int resultCapacity;

void backtrack(int* current, int currentSize, int* candidates, int candidatesSize, int remaining, int startIndex) {
    if (remaining == 0) {
        if (*resultSize >= resultCapacity) {
            resultCapacity *= 2;
            result = realloc(result, resultCapacity * sizeof(int*));
            *columnSizes = realloc(*columnSizes, resultCapacity * sizeof(int));
        }
        result[*resultSize] = malloc(currentSize * sizeof(int));
        for (int i = 0; i < currentSize; i++) {
            result[*resultSize][i] = current[i];
        }
        (*columnSizes)[*resultSize] = currentSize;
        (*resultSize)++;
        return;
    }
    
    for (int i = startIndex; i < candidatesSize; i++) {
        if (candidates[i] > remaining) {
            break; // Early termination
        }
        current[currentSize] = candidates[i];
        backtrack(current, currentSize + 1, candidates, candidatesSize, remaining - candidates[i], i);
    }
}

int** combinationSum(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes) {
    qsort(candidates, candidatesSize, sizeof(int), compare);
    
    resultCapacity = 100;
    result = malloc(resultCapacity * sizeof(int*));
    *returnColumnSizes = malloc(resultCapacity * sizeof(int));
    *returnSize = 0;
    
    int* current = malloc(target * sizeof(int));
    backtrack(current, 0, candidates, candidatesSize, target, 0);
    
    free(current);
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(N^(T/M))

Same worst case as brute force, but with significant practical improvements due to pruning

✓ Linear Growth

Space Complexity

O(T/M)

Space for recursion stack and storing results

✓ Linear Space

Constraints

1 ≤ candidates.length ≤ 30
2 ≤ candidates[i] ≤ 40
All elements of candidates are distinct
1 ≤ target ≤ 40
The number of unique combinations ≤ 150

89.5K Views

High Frequency

~25 min Avg. Time

2.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Backtracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler