Saltar al contenido principal
Interactive Algorithm Education

Visualize & Master Algorithms & Data Structures

Explore classic & modern sorting algorithms, efficient searching techniques, and interactive data structure visualizations — all with real-time step-by-step animation, comparisons, swaps, and Big-O metrics.

Dynamic Programming Visualizer

Coin Change

Paso 0 / 0
Speed 100ms
Step Progress 0 / 0
Table Size 0×0
Cells Filled 0
Status Ready
Uncomputed
Filling
Optimal path
0 / base case
Step Explanation

Select an algorithm and press Play to watch the table fill in.

—
Pseudocode
 

Coin Change Problem

Elementary (2/5) ~1 hora Minimum number of coins Unbounded knapsack variant DP: amount vs coins Greedy does not always work Prereqs: Programación dinámica, Knapsack Problem
Quick Reference

Coin Change

Coin Change (minimum coins) finds the fewest coins that sum to a target amount using an unlimited supply of given denominations. dp[i][a] is the minimum coins using the first i denominations to make amount a.

Difficulty: Elementary (2/5) dp

Complexity

Best Time
O(nA)
Average Time
O(nA)
Worst Time
O(nA)
Space
O(nA)

When to Use

For change-making, coin systems, and unbounded-knapsack-style resource problems.

Pros

  • Exact minimum via DP
  • Handles unlimited coin supply naturally
  • Classic example of choosing "include or not" states

Cons

  • O(nA) time and space
  • Greedy fails for arbitrary denominations
  • Infinity handling can confuse beginners

History

The coin change problem is one of the oldest optimization problems in computing, popularized through programming-contest literature and as a canonical dynamic-programming teaching example.

Coin Change Problem pregunta: dado un conjunto de denominaciones de monedas y un monto objetivo, ¿cuál es el mínimo número de monedas necesario para alcanzar ese monto?

Es una variante de unbounded knapsack donde cada moneda puede usarse infinitamente. La versión que minimiza monedas usa DP; la versión que cuenta el número de formas también.

Cómo Funciona

  1. Inicializa dp[0] = 0, dp[1..amount] = ∞.
  2. Recurre para cada monto a de 1 a amount:
    • “Para cada moneda c: si a >= c, dp[a] = min(dp[a], 1 + dp[a - c]).”
  3. Resultado: dp[amount] (o -1 si es ∞).

Idea Clave

La optimal substructure es clara: si la solución óptima para monto a usa una moneda c, entonces el resto debe ser la solución óptima para a - c. Como las monedas son ilimitadas, puedes reutilizar la misma denominación.

Greedy no siempre funciona: con denominaciones [1, 3, 4] y monto 6, greedy toma 4 + 1 + 1 = 3 monedas, pero la óptima es 3 + 3 = 2.

Ejemplo Trabajado

Monedas: [1, 2, 5], monto: 11.

Tabla DP (monto 0..11):

dp[0] = 0

dp[1] = min(dp[0] + 1) = 1

dp[2] = min(dp[1] + 1, dp[0] + 1) = 1

dp[3] = min(dp[2] + 1, dp[1] + 1) = 2

dp[4] = min(dp[3] + 1, dp[2] + 1) = 2

dp[5] = min(dp[4] + 1, dp[3] + 1, dp[0] + 1) = 1

dp[6] = min(dp[5] + 1, dp[4] + 1, dp[1] + 1) = 2

dp[7] = min(dp[6] + 1, dp[5] + 1, dp[2] + 1) = 2

dp[8] = min(dp[7] + 1, dp[6] + 1, dp[3] + 1) = 3

dp[9] = min(dp[8] + 1, dp[7] + 1, dp[4] + 1) = 3

dp[10] = min(dp[9] + 1, dp[8] + 1, dp[5] + 1) = 2

dp[11] = min(dp[10] + 1, dp[9] + 1, dp[6] + 1) = 3

Resultado: dp[11] = 3 (monedas: 5 + 5 + 1).

Casos Extremos y Trampas

  • Imposible — si dp[amount] permanece ∞, retorna -1.
  • Greedy — funciona para sistemas canónicos (USD, EUR) pero falla en general.
  • Contar formas — ways[a] = sum(ways[a - c] for c in coins) cuenta el número de combinaciones.
  • BFS — modela como shortest path en DAG donde cada arista consume una moneda.

Variantes

VarianteObjetivoComplejidad
Min coinsMinimizar númeroO(n × amount)
Count waysContar combinacionesO(n × amount)
GreedyAproximación canónicaO(n log n)

Aplicaciones

  • Sistemas de pago — cambio mínimo en cajeros
  • Planificación de recursos — asignación mínima de recursos
  • Enseñanza — introduce unbounded DP y límites de greedy

Trayectoria de Práctica

  1. Implementa DP para min coins; traza el ejemplo [1,2,5], monto 11.
  2. Muestra un contraejemplo donde greedy falla.
  3. Extiende para contar el número de formas.
  4. ¿Por qué BFS también resuelve este problema?
  5. Investiga coin systems canónicos: ¿cuándo greedy es óptimo?