Combination Sum

Combination Sum - Problem

Array Backtracking Medium

Given an array of distinct integers candidates and a target integer target, return a list of all unique combinations of candidates where the chosen numbers sum to target.

You may return the combinations in any order. The same number may be chosen from candidates an unlimited number of times. Two combinations are unique if the frequency of at least one of the chosen numbers is different.

The test cases are generated such that the number of unique combinations that sum up to target is less than 150 combinations for the given input.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: Two combinations sum to 7: [2,2,3] (2+2+3=7) and [7] (7=7). We can use each candidate unlimited times.

Example 2 — Multiple Solutions

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

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

💡 Note: Three combinations sum to 8: [2,2,2,2] (2+2+2+2=8), [2,3,3] (2+3+3=8), and [3,5] (3+5=8).

Example 3 — No Solution

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

› Output: []

💡 Note: No combination of [2] can sum to 1, since 2 > 1 and we need positive integers.

Constraints

1 ≤ candidates.length ≤ 30
2 ≤ candidates[i] ≤ 40
All elements of candidates are distinct
1 ≤ target ≤ 40

Visualization

Tap to expand

Asked in

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

The key insight is to use backtracking to build combinations incrementally, allowing unlimited reuse of candidates. Best approach is optimized backtracking with sorting for early termination. Time: O(2^(target/min)), Space: O(target/min)

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Backtracking with Sorting	O(2^(target/min))	O(target/min)	Sort candidates first and use early termination for better pruning
Brute Force - Generate All Possible Combinations	O(k^(target/min))	O(k^(target/min))	Generate all possible combinations of any length and filter those that sum to target
Backtracking with Recursion	O(2^target)	O(target/min)	Recursively build combinations, backtracking when sum exceeds target

Optimized Backtracking with Sorting — Algorithm Steps

Sort candidates array in ascending order
Use backtracking with early termination
If current candidate > remaining target, break (all subsequent are larger)
Continue recursively building combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Candidates

Sort array: [2,3,6,7]

Early Termination

If candidate > remaining, break (all next are larger)

Efficient Pruning

Avoid exploring impossible branches

Code -

solution.c — C

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

int** result;
int* resultSizes;
int resultCount;
int resultCapacity;

void addResult(int* combo, int size) {
    if (resultCount >= resultCapacity) {
        resultCapacity *= 2;
        result = realloc(result, resultCapacity * sizeof(int*));
        resultSizes = realloc(resultSizes, resultCapacity * sizeof(int));
    }
    result[resultCount] = malloc(size * sizeof(int));
    memcpy(result[resultCount], combo, size * sizeof(int));
    resultSizes[resultCount] = size;
    resultCount++;
}

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

void backtrack(int* candidates, int candidatesSize, int remaining, int* currentCombo, 
               int comboSize, int startIdx) {
    if (remaining == 0) {
        addResult(currentCombo, comboSize);
        return;
    }
    
    for (int i = startIdx; i < candidatesSize; i++) {
        int candidate = candidates[i];
        if (candidate > remaining) {
            break;  // Early termination
        }
        
        currentCombo[comboSize] = candidate;
        backtrack(candidates, candidatesSize, remaining - candidate, 
                 currentCombo, comboSize + 1, i);
    }
}

int** solution(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes) {
    result = malloc(1000 * sizeof(int*));
    resultSizes = malloc(1000 * sizeof(int));
    resultCount = 0;
    resultCapacity = 1000;
    
    qsort(candidates, candidatesSize, sizeof(int), compare);  // Sort for better pruning
    
    int* currentCombo = malloc(target * sizeof(int));
    backtrack(candidates, candidatesSize, target, currentCombo, 0, 0);
    free(currentCombo);
    
    *returnSize = resultCount;
    *returnColumnSizes = resultSizes;
    return result;
}

int main() {
    int candidates[] = {2, 3, 6, 7};
    int target = 7;
    int returnSize;
    int* returnColumnSizes;
    
    int** result = solution(candidates, 4, target, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(target/min))

Maximum number of combinations possible, with sorting providing better pruning

✓ Linear Growth

Space Complexity

O(target/min)

Maximum recursion depth is target divided by smallest candidate

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Optimized Backtracking with Sorting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler