LietCode
Combination Sum III

Combination Sum III

Abhi's photo
Abhi
·

3 min read

Explain the Problem

Find all possible combinations of k numbers that add up to a number n, given that only numbers from 1 to 9 can be used and each combination should be a unique set of numbers.

All numbers will be positive integers, and no duplicate combinations are allowed.

Example:

Input: k = 3, n = 7

Output:

[
  [1, 2, 4]
]

1) Explain the problem

Given two integers k and n, return all possible combinations of k numbers that add up to a number n, given that only numbers from 1 to 9 can be used and each combination should be a unique set of numbers.

2) Short easy to remember solution/approach

  1. Use backtracking to try different combinations.

  2. Ensure the combination length is k and the sum is n.

3) Solution in JavaScript with code commenting

function combinationSum3(k, n) {
    const result = [];

    function backtrack(start, currentCombination, currentSum) {
        if (currentCombination.length === k && currentSum === n) {
            result.push([...currentCombination]);
            return;
        }

        if (currentCombination.length > k || currentSum > n) {
            return;
        }

        for (let i = start; i <= 9; i++) {
            currentCombination.push(i);
            backtrack(i + 1, currentCombination, currentSum + i);
            currentCombination.pop();
        }
    }

    backtrack(1, [], 0);
    return result;
}

// Example usage:
const k = 3;
const n = 7;
console.log(combinationSum3(k, n)); // Output: [[1, 2, 4]]

4) Explanation the solution in an easy-to-understand way with real-life example

Imagine you have a list of numbers from 1 to 9. You want to find all possible ways to pick k numbers from this list so that their sum is exactly n.

For example, if you want to pick 3 numbers (k = 3) that add up to 7 (n = 7), one possible way is to pick 1, 2, and 4 because 1 + 2 + 4 = 7.

5) Code explanation in pointers

  • Initialize result array: This array will store all valid combinations.

  • Backtracking function: This function will try different combinations of numbers.

  • Base case: If the current combination has k numbers and their sum is n, add it to the result.

  • Early stopping: If the combination length exceeds k or the sum exceeds n, stop further exploration.

  • Loop through numbers: From the current number to 9, try each number in the combination.

  • Recursive call: Add the current number to the combination and recurse to the next number.

  • Backtrack: Remove the last number from the combination to try the next possibility.

  • Return result: After exploring all possibilities, return the result array.

6) Complexities

  • Time complexity: (O(2^9)) because there are 9 numbers and each number can either be included or not in the combination.

  • Space complexity: (O(k)) for the recursion stack and combination array.

backtracking