Combination Sum II - Practice Coding Problems

Combination Sum II - Problem

Array Backtracking Medium

You're given a collection of candidate numbers and a target number. Your mission is to find all unique combinations where the candidates sum exactly to the target.

Key constraints:

Each number in candidates may only be used once per combination
The solution set must not contain duplicate combinations
The same number may appear multiple times in the input array

Example: If candidates = [10,1,2,7,6,1,5] and target = 8, valid combinations include [1,1,6], [1,2,5], [1,7], and [2,6].

This is a classic backtracking problem that tests your ability to explore all possible combinations while avoiding duplicates efficiently.

Input & Output

example_1.py — Basic Case

$ Input: candidates = [10,1,2,7,6,1,5], target = 8

› Output: [[1,1,6],[1,2,5],[1,7],[2,6]]

💡 Note: These are all unique combinations that sum to 8. Note that [1,1,6] uses both 1's from the array, and we avoid duplicates like having [1,7] appear twice.

example_2.py — No Solution

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

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

💡 Note: We can form 5 using [5] directly, or combining [1,2,2]. Note that [2,2,1] is the same as [1,2,2] so we only include one.

example_3.py — Single Element

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

› Output: []

💡 Note: No combination can sum to 1 since our only candidate is 2, which is greater than the target.

Constraints

1 ≤ candidates.length ≤ 100
1 ≤ candidates[i] ≤ 50
1 ≤ target ≤ 30
Each number in candidates may only be used once in the combination
All values in candidates are positive integers

Visualization

Tap to expand

Understanding the Visualization

Sort the Coins

Arrange candidates in ascending order: [1,1,2,5,6,7,10]

Start Building Combinations

At each level, decide whether to include the current coin

Skip Duplicates

When we see the same coin value at the same level, skip it to avoid duplicate combinations

Prune Invalid Paths

If current sum exceeds target, stop exploring this branch

Collect Valid Solutions

When sum equals target, add the combination to results

Key Takeaway

🎯 Key Insight: Sorting enables systematic duplicate avoidance while backtracking explores all valid paths efficiently through early pruning.

Asked in

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

The optimal approach uses backtracking with sorting to efficiently explore all valid combinations. By sorting the candidates array first, we can easily skip duplicates at the same recursion level and prune branches early when the current sum exceeds the target. This ensures we find all unique combinations without generating duplicates.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking with Sorting (Optimal)	O(2^n)	O(target)	Sort candidates and use backtracking to avoid duplicates efficiently
Brute Force (Generate All Subsets)	O(2^n)	O(2^n)	Generate all possible subsets and filter those that sum to target

Backtracking with Sorting (Optimal) — Algorithm Steps

Sort the candidates array to group duplicates together
Use backtracking to build combinations starting from each position
Skip duplicate elements at the same recursion level
Prune branches when current sum exceeds target
Add valid combinations to the result when target is reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort candidates to group duplicates together

Start Backtracking

Begin exploring combinations from index 0

Skip Duplicates

At each level, skip duplicate values already processed

Prune Early

Stop exploring when current sum exceeds target

Code -

solution.c — C

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

#define MAX_COMBINATIONS 1000
#define MAX_SIZE 20

int resultCount = 0;
int result[MAX_COMBINATIONS][MAX_SIZE];
int resultSizes[MAX_COMBINATIONS];

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

void backtrack(int* candidates, int candSize, int remaining, int start, int* path, int pathSize) {
    if (remaining == 0) {
        memcpy(result[resultCount], path, pathSize * sizeof(int));
        resultSizes[resultCount] = pathSize;
        resultCount++;
        return;
    }
    
    for (int i = start; i < candSize; i++) {
        // Skip duplicates at the same level
        if (i > start && candidates[i] == candidates[i-1]) {
            continue;
        }
        
        // Pruning: if current number exceeds remaining target
        if (candidates[i] > remaining) {
            break;
        }
        
        path[pathSize] = candidates[i];
        backtrack(candidates, candSize, remaining - candidates[i], i + 1, path, pathSize + 1);
    }
}

int** combinationSum2(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes) {
    qsort(candidates, candidatesSize, sizeof(int), compare);
    
    resultCount = 0;
    int* path = malloc(MAX_SIZE * sizeof(int));
    backtrack(candidates, candidatesSize, target, 0, path, 0);
    
    *returnSize = resultCount;
    *returnColumnSizes = malloc(resultCount * sizeof(int));
    int** finalResult = malloc(resultCount * sizeof(int*));
    
    for (int i = 0; i < resultCount; i++) {
        (*returnColumnSizes)[i] = resultSizes[i];
        finalResult[i] = malloc(resultSizes[i] * sizeof(int));
        memcpy(finalResult[i], result[i], resultSizes[i] * sizeof(int));
    }
    
    free(path);
    return finalResult;
}

int main() {
    // Input parsing and solution call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case still explores exponential combinations, but with significant pruning in practice

⚠ Quadratic Growth

Space Complexity

O(target)

Recursion depth limited by target value divided by minimum element

✓ Linear Space

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

Backtracking with Sorting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler