Contenido del curso
DFS
- 6

Cómo recorre nodos el algoritmo DFS
04:49 min - 7

Implementación de DFS recursivo para búsqueda en árboles
12:10 min - 8

Búsqueda en Profundidad (DFS) para Grafos: Enfoque Iterativo y Recursivo
01:27 min - 9

Inorder, Preorder y Postorder en árboles
07:09 min - 10

Suma de caminos raíz a hoja en árboles
02:04 min - 11

Suma de caminos raíz a hoja con DFS
07:31 min - 12

Playground: Sum Root to Leaf Numbers
- 13

Implementación de Algoritmo DFS en Árboles Binarios con Golang
15:03 min - 14

Número de islas con DFS en matrices
02:32 min - 15

Problema de islas resuelto con DFS
08:50 min - 16

Playground: Number of Islands
- 17

Número de islas con DFS recursivo en Python
10:18 min - 18

Ejercicios Prácticos de Búsqueda en Profundidad (DFS)
02:22 min - 19

Algoritmos de Búsqueda en Profundidad (DFS) en Problemas Comunes
06:19 min
BFS
- 20

Cómo BFS recorre grafos por niveles
02:05 min - 21

Implementación de BFS con colas en Python
08:42 min - 22

Mínimos movimientos del caballo en ajedrez
02:55 min - 23

Minimum Knight's Move con BFS
08:11 min - 24

Playground: Minimum Knights Moves
- 25

Resolución de Problemas de Caballos de Ajedrez con BFS en Python
17:49 min - 26

Propagación BFS en Rotting Oranges
03:50 min - 27

Resolución de Rotting Oranges usando BFS
08:43 min - 28

Playground: Rotting Oranges
- 29

Implementación de BFS para naranjas podridas
23:44 min - 30

Puente más corto entre islas con BFS
03:38 min - 31

Shortest Bridge: combina DFS y BFS
07:35 min - 32

Playground: Shortest Bridge Between Islands
- 33

Shortest Bridge con DFS y BFS en Python
14:57 min - 34

Búsqueda en anchura: Ejercicios prácticos y aplicaciones
03:41 min - 35

Ejercicios avanzados de búsqueda en anchura (BFS) en programación
08:47 min
Backtrack
- 36

Backtracking para encontrar soluciones válidas
04:20 min - 37

Combinaciones de letras en teclado telefónico
Viendo ahora - 38

Combinaciones de teclado con backtracking
09:19 min - 39

Generación de combinaciones de letras con teclados numéricos en C++
14:08 min - 40

Playground: Letter Combinations of a Phone Number
- 41

Generación de Direcciones IP Válidas a partir de Cadenas Numéricas
03:51 min - 42

Backtracking para generar IPs válidas
28:16 min - 43

Playground: Restore IP Addresses
- 44

Búsqueda de Palabras en Matrices: Solución y Complejidad
02:54 min - 45

Word Search con DFS y backtracking
08:30 min - 46

Playgrund: Word Search
- 47

Búsqueda de palabras en matrices con DFS
18:18 min - 48

Resolución del problema de las n reinas en ajedrez
01:08 min - 49

Ejercicios de Backtracking: Combinaciones y Permutaciones
01:05 min - 50

Combinaciones y Permutaciones con Backtracking
02:14 min
Próximos pasos
Combinaciones de letras en teclado telefónico
Resumen
Combinar letras a partir de un número telefónico es uno de esos retos clásicos de algoritmos que mezcla recursión, backtracking y pensamiento combinatorio. Si estás preparando entrevistas técnicas o estudiando estructuras de datos, el problema Letter Combinations of a Phone Number te enseña a generar todas las combinaciones posibles de letras asociadas a una secuencia de dígitos, tal como funcionan las teclas de un teléfono.
¿Qué pide el problema Letter Combinations of a Phone Number?
El enunciado es directo: recibes una cadena con dígitos del 2 al 9 y debes devolver, en cualquier orden, todas las combinaciones de letras que esos números podrían representar. La asignación sigue el mapeo clásico de un teclado telefónico, donde cada número agrupa entre tres y cuatro letras.
Hay un detalle importante que no puedes pasar por alto: los dígitos 0 y 1 no tienen letras asignadas. Por eso el rango válido empieza en 2 y termina en 9. Si el input incluyera un 1 o un 0, no habría nada que combinar para esos botones.
¿Qué significa que el problema acepte cualquier orden en la salida? Que no importa la secuencia en la que devuelvas las combinaciones. El evaluador valida el contenido del arreglo, no el orden de los elementos dentro de él.
¿Cómo se interpreta la entrada y la salida del ejercicio?
Piensa en el ejemplo más sencillo: la entrada es la cadena 23. El número 2 representa las letras a, b, c y el número 3 representa d, e, f. Tu tarea es combinar cada letra del primer dígito con cada letra del segundo dígito.
La salida esperada incluye estas combinaciones:
- a con d, a con e, a con f.
- b con d, b con e, b con f.
- c con d, c con e, c con f.
En total, nueve combinaciones. Y aquí viene lo interesante: si agregaras un dígito más, el número de combinaciones crecería de forma multiplicativa, no aditiva. Esa es la pista clave para entender por qué este problema se resuelve naturalmente con recursión o backtracking.
¿Por qué crecen tan rápido las combinaciones? Porque por cada nuevo dígito multiplicas las opciones previas por la cantidad de letras del nuevo botón. Tres dígitos como el 234 ya generan 3 por 3 por 3 igual a 27 combinaciones.
¿Cómo plantear la solución antes de codificar?
Antes de tocar el editor, conviene que dibujes el problema en papel. Imagina tu propio número telefónico marcado en el teclado: ¿qué palabras o secuencias de letras podrías formar si por cada tecla eligieras una letra distinta? Esa visualización mental es la base del enfoque algorítmico.
Un buen punto de partida es identificar tres elementos:
- El mapeo entre dígitos y letras, que puedes guardar en un diccionario o estructura similar.
- La estrategia de combinación, que recorre cada dígito y une sus letras con las combinaciones acumuladas hasta ese punto.
- El caso base, que define qué hacer cuando la cadena de entrada está vacía o cuando ya procesaste todos los dígitos.
No te apresures a escribir código. Resolver el problema en tu cabeza o en una hoja te permite detectar casos borde como entradas vacías, dígitos repetidos o cadenas largas que disparan el número de combinaciones.
¿Qué habilidades algorítmicas entrena este reto?
Resolver Letter Combinations of a Phone Number desarrolla varias habilidades que aparecen una y otra vez en entrevistas técnicas y en problemas reales de software.
- Pensamiento recursivo: descomponer un problema grande en subproblemas idénticos más pequeños.
- Backtracking: construir soluciones parciales y retroceder cuando ya exploraste un camino.
- Manejo de estructuras tipo diccionario o hashmap para asociar dígitos con sus letras correspondientes.
- Generación de productos cartesianos, que es exactamente lo que ocurre al combinar letras de varios dígitos.
Ahora es tu turno. Tómate unos minutos para pensar cómo abordarías el problema sin escribir código todavía. ¿Usarías recursión pura, una solución iterativa con bucles anidados o backtracking explícito? Déjame en los comentarios cuál enfoque te parece más natural y por qué.