Combination Sum II

Problem

Given a collection of candidate numbers (candidates) and a target number (target), find all unique combinations in candidates where the candidate numbers sum to target.

Each number in candidates may only be used once in the combination.

Note: The solution set must not contain duplicate combinations.

Example 1:

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

Example 2:

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

Intuition

The problem involves finding all unique combinations in the given array candidates where the candidate numbers sum to the target. Each number in candidates may only be used once in the combination, and the solution set must not contain duplicate combinations. This problem can be solved using a backtracking approach.

Approach

Sort the Candidates:

Sort the array candidates to ensure that duplicates are adjacent and can be easily skipped during the backtracking process.
Initialize Result List:

Create an empty list res to store the resulting combinations.
Backtracking Function:

Implement a backtracking function (backtrack) that takes three parameters: the current combination cur, the current position pos, and the remaining target target.
In the base case:
If target is equal to 0, add a copy of the current combination to the result res.
If target is less than or equal to 0, return.
Use a loop to iterate through the candidates starting from the current position pos.
Skip duplicates by comparing the current candidate with the previous one.
Include the current candidate in the current combination and recursively call the backtrack function with the updated parameters.
Backtrack by removing the last element from the current combination.
Call Backtrack:

Call the backtrack function with initial values: an empty list for the current combination, starting position 0, and the target value.
Return Result:

Return the final result res.

Complexity

• Time complexity:

The time complexity is O(2^n), where n is the length of the array candidates. This is because each element has two choices (include or exclude) for each recursive call, leading to 2^n possible combinations.

• Space complexity:

The space complexity is O(n) due to the recursion stack. Additionally, the space required for the cur list contributes to the space complexity. The result res contains combinations, each with an average length of n/2, resulting in a space complexity of O(n * 2^n).

Code

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        candidates = sorted(candidates)
        res = []
 
        def backtrack(cur, pos, target):
            if target == 0:
                res.append(cur.copy())
                return
            elif target <= 0:
                return
 
            prev = -1
            for i in range(pos, len(candidates)):
                if candidates[i] == prev:
                    continue
                cur.append(candidates[i])
                backtrack(cur, i + 1, target - candidates[i])
                cur.pop()
                prev = candidates[i]
            
        backtrack([], 0, target)
        return res