Most Expensive Item That Can Not Be Bought

Most Expensive Item That Can Not Be Bought - Problem

The Frobenius Coin Problem

Alice is shopping at a magical market where every possible price exists as an item - there's an item priced at $1, $2, $3, and so on infinitely. She has two types of coins with prime denominations: primeOne and primeTwo, and she has an infinite supply of both.

Alice wants to find the most expensive item that she cannot possibly buy using any combination of her two coin types. This is a classic problem in number theory known as the Frobenius problem.

Example: If Alice has coins of denominations 3 and 5, she cannot buy items priced at 1, 2, 4, or 7, but she can buy everything from 8 onwards. So the answer would be 7.

Goal: Return the price of the most expensive item Alice cannot buy.

Input & Output

example_1.py — Basic Case

$ Input: primeOne = 3, primeTwo = 5

› Output: 7

💡 Note: With coins 3 and 5, we cannot make amounts 1, 2, 4, and 7. But we can make 8 (3+5), 9 (3+3+3), 10 (5+5), 11 (3+3+5), and all amounts ≥ 8. So 7 is the largest impossible amount.

example_2.py — Larger Primes

$ Input: primeOne = 2, primeTwo = 7

› Output: 5

💡 Note: With coins 2 and 7, we cannot make amounts 1, 3, and 5. We can make: 2, 4 (2+2), 6 (2+2+2), 7, 8 (2+2+2+2), 9 (2+7), etc. The largest impossible amount is 5.

example_3.py — Small Primes

$ Input: primeOne = 2, primeTwo = 3

› Output: 1

💡 Note: With coins 2 and 3, we can only make even amounts with 2s, and amounts 3,5,6,7,8,... with combinations. Only 1 cannot be made, so the answer is 1.

Constraints

2 ≤ primeOne, primeTwo ≤ 10³
primeOne and primeTwo are distinct prime numbers
The result will always be a positive integer

Visualization

Tap to expand

Understanding the Visualization

Identify Patterns

With coins 3 and 5, small amounts like 1, 2, 4 cannot be made

Find the Transition

Starting from amount 8, every amount can be made using coin combinations

Apply Formula

The mathematical formula a×b - a - b gives us the largest impossible amount directly

Key Takeaway

🎯 Key Insight: For two coprime numbers (like distinct primes), the Frobenius formula a×b - a - b gives us the largest amount that cannot be represented as their linear combination. This elegant mathematical result turns a complex combinatorial problem into a simple arithmetic calculation!

Asked in

G Google 35 ⊞ Microsoft 28 a Amazon 22 f Meta 18

This is a classic Frobenius coin problem. The optimal solution uses the mathematical formula primeOne × primeTwo - primeOne - primeTwo for two coprime numbers, giving us O(1) time complexity. Since distinct primes are always coprime, this formula applies directly. The DP approach helps understand the problem but the mathematical insight provides the elegant solution.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming Approach	O(a × b)	O(a × b)	Use DP to mark all achievable amounts up to the theoretical limit
Mathematical Formula (Optimal)	O(1)	O(1)	Use the Frobenius formula directly: primeOne × primeTwo - primeOne - primeTwo

Dynamic Programming Approach — Algorithm Steps

Calculate upper bound using Frobenius formula: primeOne × primeTwo - primeOne - primeTwo
Create boolean array to track achievable amounts
Mark 0 as achievable (base case)
For each achievable amount, mark amount + primeOne and amount + primeTwo as achievable
Find the largest unachievable amount

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create array where achievable[0] = true

Fill DP

For each achievable amount, mark amount + coin1 and amount + coin2 as achievable

Find Maximum

Scan array backwards to find largest unachievable amount

Code -

solution.c — C

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

int mostExpensiveItemThatCanNotBeBought(int primeOne, int primeTwo) {
    int upperBound = primeOne * primeTwo;
    
    // DP array to track achievable amounts
    bool* achievable = (bool*)calloc(upperBound, sizeof(bool));
    achievable[0] = true;  // 0 can always be achieved
    
    // Fill the DP array
    for (int i = 0; i < upperBound; i++) {
        if (achievable[i]) {
            if (i + primeOne < upperBound) {
                achievable[i + primeOne] = true;
            }
            if (i + primeTwo < upperBound) {
                achievable[i + primeTwo] = true;
            }
        }
    }
    
    // Find the largest unachievable amount
    int result = -1;
    for (int i = 1; i < upperBound; i++) {
        if (!achievable[i]) {
            result = i;
        }
    }
    
    free(achievable);
    return result;
}

int main() {
    int primeOne, primeTwo;
    scanf("%d %d", &primeOne, &primeTwo);
    printf("%d\n", mostExpensiveItemThatCanNotBeBought(primeOne, primeTwo));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(a × b)

We iterate through all numbers up to a×b and for each achievable number, we check two possibilities

✓ Linear Growth

Space Complexity

O(a × b)

We store a boolean array of size equal to the upper bound

✓ Linear Space

52.3K Views

Medium Frequency

~15 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 Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler