Combination Sum

Combination Sum is a classic problem in computer science, often encountered in the context of algorithms and data structures. To understand this problem, let's break it down using first principles.

Understanding the Problem

The problem statement of "Combination Sum" typically goes like this: Given an array of distinct integers and a target number, find all unique combinations in the array where the numbers sum up to the target. The same number may be chosen from the array multiple times.

For example:

  • Input: array = [2,3,6,7], target = 7
  • Output: [[2,2,3], [7]]

This output shows that 2 + 2 + 3 = 7 and 7 = 7 are the two unique combinations that sum up to the target value 7.

First Principles Breakdown

  1. Combination: A combination is a selection of items from a collection, such that the order of selection does not matter. In our case, the items are the numbers in the given array.

  2. Unique Combinations: These are distinct sets of numbers that don't repeat in the context of our problem. For instance, [2,2,3] and [3,2,2] are considered the same combination since the order of numbers does not matter.

  3. Sum: This is a basic arithmetic operation where values are added together. In this problem, we are interested in the sum of numbers equaling a specific target.

  4. Recursive and Backtracking Approach: This problem is commonly solved using recursion and backtracking. Recursion allows us to explore each possibility, and backtracking helps to eliminate paths that do not lead to a solution.

Solving the Problem

  1. Start with an Empty Combination: We begin with an empty set and a target sum.

  2. Explore Choices: For each number in the array, we have two choices: either include the number in our current combination or exclude it.

  3. Recurse with Updated Parameters: If we include the number, we subtract it from the target sum and recursively call the same function with the new target sum and the current combination.

  4. Backtrack: After exploring the path with the included number, we backtrack, i.e., we remove the number from our current combination (to revert the state) and explore the possibility of excluding the number.

  5. Base Cases:

    • If the target sum becomes 0, we have found a valid combination.
    • If the target sum becomes negative or there are no more numbers to process, we cannot form a valid combination.
  6. Avoid Duplicate Combinations: We can avoid duplicates by processing each distinct number only once in each recursive call.

Algorithm in Steps

  1. Initialize an empty list to store the final combinations.
  2. Sort the input array to handle duplicates efficiently.
  3. Create a recursive function that takes the current combination, the starting index in the array, and the remaining target sum.
  4. In the recursive function, if the target sum is 0, add the current combination to the final list.
  5. Iterate over the array starting from the given index. For each number, add it to the current combination, and recursively call the function with the updated target sum and the next index.
  6. After the recursive call, backtrack by removing the last added number from the current combination.
  7. Continue this process until all combinations are explored.


This algorithm effectively explores all possible combinations that sum up to the target, ensuring that each combination is unique and that we don't revisit combinations that have already been explored. The use of recursion and backtracking is fundamental in navigating through the potential combinations, and the problem itself is a good exercise in understanding these concepts in depth.