39. Combination Sum — LeetCode(Python)

Palash Sharma
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 = 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 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 🙏

--

--