# 39. Combination Sum — LeetCode(Python)

I got you!

# Problem:

Given an array of **distinct** integers `candidates`

and a target integer `target`

, return *a list of all **unique combinations** of *`candidates`

* where the chosen numbers sum to *`target`

*.* You may return the combinations in **any order**.

The **same** number may be chosen from `candidates`

an **unlimited number of times**. Two combinations are unique if the frequency of at least one of the chosen numbers is different.

It is **guaranteed** that the number of unique combinations that sum up to `target`

is less than `150`

combinations for the given input.

**Example 1:**

**Input:** candidates = [2,3,6,7], target = 7

**Output:** [[2,2,3],[7]]

**Explanation:**

2 and 3 are candidates, and 2 + 2 + 3 = 7. Note that 2 can be used multiple times.

7 is a candidate, and 7 = 7.

These are the only two combinations.

**Example 2:**

**Input:** candidates = [2,3,5], target = 8

**Output:** [[2,2,2,2],[2,3,3],[3,5]]

**Example 3:**

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

**Output:** []

**Constraints:**

`1 <= candidates.length <= 30`

`1 <= candidates[i] <= 200`

- All elements of
`candidates`

are**distinct**. `1 <= target <= 500`

# Solution:

## Explanation —

We use a backtracking algorithm to solve this problem.

We iterate through the array ** candidates** and call our

**method recursively.**

*dfs*At each step, we have two choices to make. The first choice is to add the current element to our current subset ** curr, **or to not add anything at all.

The base case of the recursion is when either a valid subset is found, in which case we add it to our result, or if our search exhausts or the sum is overreached, in both of which cases we return from the current function.

The ** curr** array is updated accordingly and so are the parameters of the recursive

**call.**

*dfs*Finally, we call our backtracking function and return the result.

## Time and Space Complexity —

The recursive tree can have a maximum depth of ** t**, if we keep adding the number 1

**times, and at each step 2 decisions are being made, so the time complexity should be of the order of O(2^**

*t***), where**

*t***is the target value.**

*t*Also, the space complexity will be the same because of the recursion stack.

Thus, if *n* is the length of the array ** candidates, **and

*t*is the target value,

Time Complexity: O(2^t)

Space Complexity: O(2^t)