Coin Change

mediumFREEDynamic ProgrammingNetflix DSA

Given coin denominations coins and a target amount, return the fewest coins needed to make up exactly amount. You may use each denomination any number of times. Return -1 if the amount cannot be made (and 0 when amount is 0).

Implement coin_change(coins, amount).

Example

Input

1,2,5
11

Output

Reasoning

coins lists the denominations $\{1, 2, 5\}$ , and each one can be used as many times as you like. amount is the target, $11$ .
The output is a count of coins, not the coins themselves: the smallest $k$ such that $k$ denominations (repeats allowed) add up to exactly $11$ .
Lower bound: even using only the biggest coin, $2 \times 5 = 10 < 11$ , so two coins can never reach $11$ . At least $3$ are needed.
Three coins do work: $5 + 5 + 1 = 11$ . Since $3$ is both reachable and a lower bound, the answer is 3.
Notice that reaching for the largest coin first is not reliable in general: with denominations $\{1, 3, 4\}$ and target $6$ , starting with $4$ forces $4 + 1 + 1$ (three coins), while $3 + 3$ needs only two.
If no combination hits the target exactly (denominations $\{2\}$ , target $3$ : every sum is even), the answer is $-1$ ; a target of $0$ needs $0$ coins.

Constraints

1 <= len(coins) <= 12
1 <= coins[i] <= 2^31 - 1
0 <= amount <= 10^4

More from Netflix DSA

Search a 2D Matrixeasy Merge Intervalsmedium Sort Colorsmedium Kth Largest Element in an Arraymedium Missing Numbereasy

Concept primer

Background Knowledge

The Coin Change problem is a classic example of a Dynamic Programming problem. Dynamic Programming is a method for solving complex problems by breaking them down into simpler subproblems, solving each subproblem only once, and storing the results to avoid redundant computation. This approach is particularly useful for problems that have overlapping subproblems or optimal substructure, meaning that the problem can be broken down into smaller subproblems and the optimal solution to the larger problem can be constructed from the optimal solutions of the subproblems.

In the context of the Coin Change problem, we are given a set of coin denominations and a target amount, and we need to find the fewest coins needed to reach the target amount. This problem can be broken down into smaller subproblems, such as finding the fewest coins needed to reach a smaller amount, and the solutions to these subproblems can be used to construct the solution to the larger problem. The key concept here is to use a bottom-up approach, where we start with the smallest subproblems and build up to the larger problem, using the solutions to the smaller subproblems to inform the solution to the larger problem.

The Coin Change problem also involves the concept of minimization, where we need to find the minimum number of coins needed to reach the target amount. This is a common theme in Dynamic Programming problems, where we need to optimize a certain objective function, such as minimizing the number of coins or maximizing the value of a certain quantity. To solve this problem, we will need to use a combination of mathematical insights, such as the concept of minimum and maximum, and algorithmic techniques, such as iteration and recursion.

Algorithm/Approach

The general approach to solving the Coin Change problem is to use a Dynamic Programming algorithm, specifically a tabulation approach. This involves creating a table to store the solutions to the subproblems, and then using this table to construct the solution to the larger problem. The algorithm will involve iterating over the possible amounts, from 0 to the target amount, and for each amount, finding the minimum number of coins needed to reach that amount.

Step-by-Step Strategy

To implement the solution, we can follow these steps:

Create a table to store the minimum number of coins needed to reach each amount from 0 to the target amount.
Initialize the table with a base case, such as 0 coins needed to reach an amount of 0.
Iterate over the possible amounts, from 1 to the target amount.
For each amount, iterate over the coin denominations and find the minimum number of coins needed to reach that amount.
Update the table with the minimum number of coins needed to reach each amount.
Return the minimum number of coins needed to reach the target amount, or -1 if it is not possible.

Common Pitfalls

Some common pitfalls to watch out for when implementing the solution include:

Not initializing the table correctly, which can lead to incorrect results.
Not handling the base case correctly, which can lead to incorrect results.
Not iterating over the coin denominations correctly, which can lead to incorrect results.
Not updating the table correctly, which can lead to incorrect results.

Time & Space Complexity

The expected time complexity of the solution is $O(n \cdot m)$ , where $n$ is the target amount and $m$ is the number of coin denominations. The expected space complexity is $O(n)$ , where $n$ is the target amount. This is because we need to store the minimum number of coins needed to reach each amount from 0 to the target amount.

solution.py

Python 3.13

Test results