Coin Change II

Coin Change II - Problem

Coin Change II presents a classic dynamic programming challenge in combinatorics. You're given an array of coins representing different denominations and an integer amount representing a target sum. Your goal is to find how many different ways you can combine these coins to make exactly that amount.

Key points:
• You have an unlimited supply of each coin type
• Order doesn't matter - [1,2] and [2,1] count as the same combination
• If the amount cannot be made, return 0
• The result fits in a 32-bit integer

For example, with coins [1, 2, 5] and amount 5, there are 4 ways: [5], [2,2,1], [2,1,1,1], [1,1,1,1,1].

Input & Output

example_1.py — Basic Case

$ Input: coins = [1,2,5], amount = 5

› Output: 4

💡 Note: There are 4 ways to make amount 5: [5], [2,2,1], [2,1,1,1], [1,1,1,1,1]

example_2.py — No Solution

$ Input: coins = [2], amount = 3

› Output: 0

💡 Note: Amount 3 cannot be made with only coin value 2 (odd amount with even coins)

example_3.py — Zero Amount

$ Input: coins = [10], amount = 0

› Output: 1

💡 Note: There is exactly one way to make amount 0: use no coins at all

Constraints

1 ≤ coins.length ≤ 300
1 ≤ coins[i] ≤ 5000
0 ≤ amount ≤ 5000
All coin values are positive integers
The answer is guaranteed to fit in a signed 32-bit integer

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses 1D Dynamic Programming with O(n×amount) time and O(amount) space. By processing coins one at a time and updating a DP array, we systematically count combinations while avoiding duplicates. The key insight is that dp[i] represents ways to make amount i, and for each coin, we update dp[amount] += dp[amount - coin] for valid amounts.

Common Approaches

✓ Dynamic Programming (2D Table)

⏱️ Time: O(n × amount) Space: O(n × amount)

Create a 2D DP table where dp[i][j] represents the number of ways to make amount j using the first i coin types. This approach systematically builds up solutions for larger amounts using previously computed results.

Optimized 1D Dynamic Programming (Optimal)

⏱️ Time: O(n × amount) Space: O(amount)

The optimal solution uses a 1D DP array where dp[i] represents the number of ways to make amount i. By processing coins one at a time and updating the array from left to right, we avoid counting duplicate combinations while using minimal space.

Dynamic Programming (2D Table) — Algorithm Steps

Create a 2D table dp[coins+1][amount+1]
Initialize: dp[i][0] = 1 (one way to make amount 0: use no coins)
For each coin and each amount, decide: use coin or don't use coin
dp[i][j] = dp[i-1][j] + dp[i][j-coin[i-1]] (if j >= coin[i-1])

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[i][0] = 1 for all i (base case)

Fill Row by Row

For each coin type, compute ways for each amount

Final Answer

dp[n][amount] contains the result

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int change(int amount, int* coins, int coinsSize) {
    int** dp = (int**)malloc((coinsSize + 1) * sizeof(int*));
    for (int i = 0; i <= coinsSize; i++) {
        dp[i] = (int*)calloc(amount + 1, sizeof(int));
    }
    
    // Base case: one way to make amount 0
    for (int i = 0; i <= coinsSize; i++) {
        dp[i][0] = 1;
    }
    
    for (int i = 1; i <= coinsSize; i++) {
        for (int j = 1; j <= amount; j++) {
            // Don't use current coin
            dp[i][j] = dp[i-1][j];
            
            // Use current coin (if possible)
            if (j >= coins[i-1]) {
                dp[i][j] += dp[i][j - coins[i-1]];
            }
        }
    }
    
    int result = dp[coinsSize][amount];
    
    // Free memory
    for (int i = 0; i <= coinsSize; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    char buffer[4096];
    fgets(buffer, sizeof(buffer), stdin);
    
    int coins[300];
    int coinsSize = 0;
    int amount = 0;
    
    char* p = strstr(buffer, "coins");
    if (p) {
        p = strchr(p, '[');
        if (p) {
            p++;
            while (*p && *p != ']') {
                if (*p >= '0' && *p <= '9') {
                    coins[coinsSize++] = (int)strtol(p, &p, 10);
                } else {
                    p++;
                }
            }
        }
    }
    
    p = strstr(buffer, "amount");
    if (p) {
        p = strchr(p, ':');
        if (p) {
            p++;
            while (*p == ' ') p++;
            amount = (int)strtol(p, NULL, 10);
        }
    }
    
    printf("%d\n", change(amount, coins, coinsSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × amount)

We fill a table of size n×amount, each cell taking O(1) time

✓ Linear Growth

Space Complexity

O(n × amount)

2D DP table storing results for all coin-amount combinations

⚡ Linearithmic Space

42.4K Views

High Frequency

~18 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (2D Table) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler