Combination Sum III

Combination Sum III - Problem

Array Backtracking Medium

Find all valid combinations of k numbers that sum up to n such that the following conditions are true:

Only numbers 1 through 9 are used.
Each number is used at most once.

Return a list of all possible valid combinations. The list must not contain the same combination twice, and the combinations may be returned in any order.

Input & Output

Example 1 — Basic Case

$ Input: k = 3, n = 7

› Output: [[1,2,4]]

💡 Note: 1 + 2 + 4 = 7. Only one combination of 3 numbers from 1-9 sums to 7.

Example 2 — Multiple Solutions

$ Input: k = 3, n = 9

› Output: [[1,2,6],[1,3,5],[2,3,4]]

💡 Note: Three valid combinations: 1+2+6=9, 1+3+5=9, and 2+3+4=9.

Example 3 — No Solution

$ Input: k = 4, n = 1

› Output: []

💡 Note: Impossible to pick 4 numbers from 1-9 that sum to only 1.

Constraints

2 ≤ k ≤ 9
1 ≤ n ≤ 60

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 🍎 Apple 12

Use backtracking to build combinations incrementally while pruning invalid branches early. The key insight is to avoid generating combinations that exceed the target sum or cannot possibly reach it. Time: O(2⁹), Space: O(k)

Common Approaches

✓ Backtracking with Pruning

⏱️ Time: O(2⁹) Space: O(k)

Use backtracking to build valid combinations incrementally. At each step, try adding the next available number and recurse. Prune branches early when the current sum exceeds the target or when it's impossible to reach the target.

Generate All Combinations

⏱️ Time: O(C(9,k) * k) Space: O(C(9,k) * k)

Generate every possible combination of k numbers from digits 1-9, then check which ones sum to n. This involves generating C(9,k) combinations and testing each sum.

Backtracking with Pruning — Algorithm Steps

Step 1: Start with empty combination and try each number 1-9
Step 2: For each choice, add to current combination and recurse
Step 3: Prune if current sum > target or remaining numbers can't reach target
Step 4: When k numbers chosen, check if sum equals target

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Numbers

At each level, try adding numbers 1-9 to current combination

Check Constraints

Prune if sum exceeds target or impossible to complete

Recurse/Backtrack

Continue deeper or backtrack when path is invalid

Code -

solution.c — C

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

int result[200][9];
int resultSizes[200];
int resultSize = 0;

void backtrack(int start, int current[], int currentSize, int remainingSum, int remainingCount) {
    if (remainingCount == 0 && remainingSum == 0) {
        for (int i = 0; i < currentSize; i++) {
            result[resultSize][i] = current[i];
        }
        resultSizes[resultSize] = currentSize;
        resultSize++;
        return;
    }
    
    if (remainingCount == 0 || remainingSum <= 0) {
        return;
    }
    
    for (int num = start; num <= 9; num++) {
        if (num > remainingSum) break;
        
        // Pruning
        if (remainingCount > 1) {
            int minPossible = (remainingCount - 1) * (num + 1) + (remainingCount - 2) * (remainingCount - 1) / 2;
            int maxPossible = (remainingCount - 1) * 9 - (remainingCount - 2) * (remainingCount - 1) / 2;
            if (remainingSum - num < minPossible || remainingSum - num > maxPossible) {
                continue;
            }
        }
        
        current[currentSize] = num;
        backtrack(num + 1, current, currentSize + 1, remainingSum - num, remainingCount - 1);
    }
}

void solution(int k, int n) {
    int current[9];
    resultSize = 0;
    backtrack(1, current, 0, n, k);
}

int main() {
    int k, n;
    scanf("%d", &k);
    scanf("%d", &n);
    
    solution(k, n);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        printf("[");
        for (int j = 0; j < resultSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < resultSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < resultSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2⁹)

Each number can be included or excluded, worst case explores all subsets

✓ Linear Growth

Space Complexity

O(k)

Recursion depth is at most k levels, plus space for current combination

✓ Linear Space

142.2K Views

Medium Frequency

~15 min Avg. Time

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

Backtracking with Pruning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler