Given an array of distinct integers, nums, and an integer, target, return a list of all unique combinations of nums where the chosen numbers sum up to the target. The combinations may be returned in any order.

An integer from nums may be chosen an unlimited number of times. Two combinations are unique if the frequency of at least one of the chosen integers is different.

Constraints:

• $1 \leq$ nums.length $\leq 30$
• $2 \leq$ nums[i] $\leq 40$
• $1 \leq$ target $\leq 40$
• All integers of nums are unique.

So far, you’ve probably brainstormed some approaches and have an idea of how to solve this problem. Let’s explore some of these approaches and figure out which one to follow based on considerations such as time complexity and any implementation constraints.

A naive approach to solve this problem would be to make all the possible combinations of nums or generate all subsets of nums that sum up to the required target.

This solution is very costly because the time complexity of achieving this is $O(n^{t/m})$, where $n$ is the number of elements in nums, $t$ is the target, and $m$ is the minimum value in nums. This is because each node in the recursion tree can have $n$ branches, and the height of the tree can grow up to $t/m$. Therefore, the total number of nodes in such a tree is bounded by $n^{t/m}$.

Because the recursive solution to this problem is very costly, let’s see if we can reduce this cost in any way. Dynamic programming helps us avoid recomputing the same subproblems. Now let’s analyze our recursive solution to see if it has the properties needed for conversion to dynamic programming.

• Optimal substructure: Let’s say we want to find the solution to the problem of counting a value, target, given $n$ numbers. Since we know the answer to the $n$ ...