# 39. Combination Sum — LeetCode(Python)

2 min readSep 2, 2022

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 = 7Output: [[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 = 8Output: [[2,2,2,2],[2,3,3],[3,5]]`

Example 3:

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

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 dfs method recursively.

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 dfs call.

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 t 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.

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)

Feel free to ask any related questions in the comment section or the links provided down below.

# I don’t have friends:

Let’s be friends!

Connect with me on:

LinkedIn

GitHub

Instagram (I know. Very professional)

Jai Shri Ram 🙏