Stamp Collection Value - Problem

You are at a post office with a collection of stamps, each with different denominations. You need to make exact postage for a letter.

Given an array stamps where stamps[i] represents the denomination of the i-th stamp, and an array counts where counts[i] represents how many stamps of denomination stamps[i] you have, find the minimum number of stamps needed to make exactly target postage.

If it's impossible to make the exact postage, return -1.

Note: You can use multiple stamps of the same denomination, but cannot exceed the available count for each denomination.

Input & Output

Example 1 — Basic Case

$ Input: stamps = [1,3,4], counts = [1,2,1], target = 11

› Output: 3

💡 Note: Use 1 stamp of value 1, 2 stamps of value 3, and 0 stamps of value 4: 1×1 + 2×3 + 0×4 = 1 + 6 + 0 = 7. Wait, that's only 7. Let me recalculate: 1×1 + 2×3 + 1×4 = 1 + 6 + 4 = 11. Total stamps used: 1 + 2 + 1 = 4 stamps. Actually, better solution: 1×3 + 2×4 = 3 + 8 = 11 using 1 + 2 = 3 stamps.

Example 2 — Impossible Case

$ Input: stamps = [2,4], counts = [1,1], target = 3

› Output: -1

💡 Note: Cannot make 3 using stamps of value 2 and 4. Any combination gives even numbers: 0, 2, 4, or 6.

Example 3 — Single Stamp Type

$ Input: stamps = [5], counts = [3], target = 10

› Output: 2

💡 Note: Use 2 stamps of value 5: 2×5 = 10. Total stamps used: 2.

Constraints

1 ≤ stamps.length ≤ 100
1 ≤ stamps[i] ≤ 1000
1 ≤ counts[i] ≤ 1000
1 ≤ target ≤ 5000

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 A Apple 6

The key insight is to use dynamic programming to build up solutions for smaller amounts. The optimal approach uses a 2D DP table where dp[i][j] represents the minimum stamps needed using the first i stamp types to make amount j. Time: O(n × target × max_count), Space: O(n × target)

Common Approaches

✓ Bottom-Up 2D Dynamic Programming

⏱️ Time: O(n × target × max_count) Space: O(n × target)

Create a 2D DP table where dp[i][j] represents minimum stamps needed using first i stamp types to make amount j. For each stamp, consider using 0, 1, 2... up to available count.

Recursive Brute Force

⏱️ Time: O(target^n) Space: O(target)

For each stamp denomination, try using 0, 1, 2, ... up to available count, then recursively solve for remaining target. Return minimum across all valid combinations.

Top-Down DP with Memoization

⏱️ Time: O(n × target × max_count) Space: O(target × n)

Same recursive approach but store results of subproblems in a memo table. Each state is defined by current stamp index and remaining target amount.

Bottom-Up 2D Dynamic Programming — Algorithm Steps

Initialize DP table with infinity except dp[0][0] = 0
For each stamp type i and amount j
Try using 0 to counts[i-1] stamps of type i
Update dp[i][j] with minimum stamps needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create 2D table with base case dp[i][0] = 0

Fill Table

For each stamp type and amount, find minimum stamps

Result

Bottom-right cell contains the answer

Code -

solution.c — C

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

int solution(int* stamps, int* counts, int n, int target) {
    // dp[i][j] = min stamps using first i types to make amount j
    int** dp = (int**)malloc((n + 1) * sizeof(int*));
    for (int i = 0; i <= n; i++) {
        dp[i] = (int*)malloc((target + 1) * sizeof(int));
        for (int j = 0; j <= target; j++) {
            dp[i][j] = INT_MAX;
        }
    }
    
    // Base case: 0 stamps needed to make amount 0
    for (int i = 0; i <= n; i++) {
        dp[i][0] = 0;
    }
    
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j <= target; j++) {
            // Don't use current stamp type
            dp[i][j] = dp[i-1][j];
            
            // Try using 1, 2, ... counts[i-1] of current stamp
            for (int k = 1; k <= counts[i-1]; k++) {
                if (j >= k * stamps[i-1]) {
                    if (dp[i-1][j - k * stamps[i-1]] != INT_MAX) {
                        int candidate = dp[i-1][j - k * stamps[i-1]] + k;
                        if (candidate < dp[i][j]) {
                            dp[i][j] = candidate;
                        }
                    }
                }
            }
        }
    }
    
    int result = dp[n][target] == INT_MAX ? -1 : dp[n][target];
    
    // Free memory
    for (int i = 0; i <= n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int stamps[100], counts[100], n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        stamps[n++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    fgets(line, sizeof(line), stdin);
    int m = 0;
    token = strtok(line, "[,]");
    while (token != NULL) {
        counts[m++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    int target;
    scanf("%d", &target);
    
    printf("%d\n", solution(stamps, counts, n, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × target × max_count)

Three nested loops: n stamp types, target amounts, max_count trials per stamp

✓ Linear Growth

Space Complexity

O(n × target)

2D DP table storing results for each stamp type and target amount

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

892 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

Stamp Collection Value - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up 2D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler