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
Viendo ahora - 37

Combinaciones de letras en teclado telefónico
01:51 min - 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
Backtracking para encontrar soluciones válidas
Resumen
El algoritmo de backtracking te permite encontrar todas las soluciones válidas a un problema descartando caminos que no llevan a una respuesta correcta. Es útil cuando necesitas explorar combinaciones, pero sin perder tiempo en rutas que ya sabes que fallan. Si estás aprendiendo estructuras de datos y algoritmos, este enfoque te ahorra cálculos innecesarios.
¿Cómo funciona el algoritmo de backtracking?
La idea es sencilla y muy parecida a cómo resolverías un laberinto en la vida real. Empiezas a caminar, y si te chocas con una pared, no te devuelves hasta el inicio: regresas solo hasta el último punto donde tenías otra posibilidad y desde ahí sigues explorando.
Cada vez que un camino te muestra que ya no llevará a una salida válida, lo abandonas. Descartas esa ruta y todas las posibles rutas que se derivarían de ella. Luego retomas desde la última bifurcación y continúas.
¿Qué hace exactamente el backtracking? Abandona una opción en cuanto detecta que no llevará a una solución válida y retrocede al último punto de decisión para probar otra alternativa.
El punto clave está en abandonar las opciones cuando veo que estas no me llevan a una solución. Eso es lo que diferencia este algoritmo de simplemente probar todo a ciegas.
¿Cuál es la diferencia entre backtracking y fuerza bruta?
Aquí viene la parte interesante. La fuerza bruta prueba absolutamente todas las combinaciones posibles, sin importar si una decisión ya invalidó el resto del camino. Combina todo con todo, choca con todas las paredes y sigue intentando.
El backtracking también busca todas las soluciones válidas, pero con criterio. En cuanto detecta que una decisión rompe la condición del problema, poda esa rama del árbol de búsqueda y se mueve a la siguiente.
¿Cuándo conviene usar backtracking en lugar de fuerza bruta? Cuando puedes validar una condición parcial antes de completar la solución. Si sabes pronto que un camino no funciona, te ahorras explorar miles de combinaciones inútiles.
La diferencia práctica es enorme: en problemas con muchas variables, la fuerza bruta puede tardar horas mientras que el backtracking resuelve en segundos.
¿Cuándo debes usar backtracking?
Este algoritmo brilla cuando el enunciado pide todas las combinaciones, todas las soluciones o todas las formas de cumplir una condición. Si tu problema requiere enumerar posibilidades válidas y descartar las inválidas, backtracking encaja perfecto.
Algunos escenarios típicos donde aplica:
- Problemas de laberintos donde existen múltiples salidas y quieres listarlas todas.
- Combinaciones y permutaciones que cumplen una restricción específica.
- Problemas de ubicación con condiciones de validez, como el clásico de ajedrez.
El problema de las N reinas como ejemplo
Un caso muy conocido es el problema de las N reinas u ocho reinas. Te dan un tablero de ajedrez y debes ubicar varias reinas de forma que ninguna ataque a otra. La condición es clara: ninguna reina puede matar a otra.
Si usaras fuerza bruta, probarías todas las combinaciones posibles de posiciones para las ocho reinas. Eso son millones de casos. Con backtracking, en cambio, colocas la primera reina, luego intentas ubicar la segunda. Si esa posición ya invalida el tablero porque se atacan, no sigues intentando colocar las seis reinas restantes desde esa configuración.
Más bien, mueves la reina problemática a otra casilla y no vuelves a probar la posición que ya descartaste. Solo continúas con las que sí cumplen la condición.
¿Qué patrón mental debes recordar al programar con backtracking?
Piensa siempre en tres pasos: explora, valida y retrocede. Avanzas por un camino, validas si la decisión actual cumple las condiciones del problema y, si no, retrocedes para probar otra opción.
Esta lógica de descarto y sigo, descarto y sigo es el núcleo del algoritmo. La aplicas tanto si buscas una sola solución como si necesitas listar todas las soluciones válidas posibles.
Cuéntame en los comentarios qué problema te gustaría resolver con backtracking en la siguiente clase.