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
Viendo ahora - 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
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
Propagación BFS en Rotting Oranges
Resumen
El problema Rotting Oranges es un clásico de entrevistas técnicas que combina matrices, propagación y búsqueda en anchura. Aquí entiendes qué pide el ejercicio, cómo se modela el cultivo y qué retos plantea para programadores que practican estructuras de datos.
¿Qué es el problema Rotting Oranges?
Es un ejercicio en el que recibes un cultivo representado como una matriz M por N. Cada celda puede contener uno de tres valores posibles que describen el estado de esa porción de tierra.
- 0: espacio vacío, sin planta.
- 1: planta de naranjas fresca.
- 2: planta de naranjas podrida.
Tu tarea es devolver el número de días que deben transcurrir hasta que ninguna celda contenga una naranja fresca. Si eso resulta imposible, retornas -1.
¿Qué representa cada número en la matriz de Rotting Oranges? El 0 es una celda vacía, el 1 es una naranja fresca y el 2 es una naranja podrida. La matriz simula un cultivo donde la podredumbre se propaga.
¿Cómo se propaga la podredumbre entre celdas adyacentes?
Una planta fresca se pudre cuando alguno de sus cuatro lados adyacentes (arriba, abajo, izquierda, derecha) contiene una planta ya podrida. La diagonal no cuenta.
El tiempo de contagio es exacto: un día por nivel de propagación. Si lo piensas como una plaga, tu planta sana se contamina al estar pegada a una infectada, y al día siguiente esa nueva infectada contamina a las suyas.
Y aquí viene lo interesante: el problema no se resuelve celda por celda en orden, sino por niveles de expansión. Cada día, todas las podridas actuales infectan a sus vecinas frescas al mismo tiempo. Eso es justo lo que modela una búsqueda en anchura o BFS.
¿Cómo se cuentan los días hasta que no queden naranjas frescas?
Imagina una matriz pequeña con varias naranjas frescas y una sola podrida en la esquina. El conteo arranca en cero y avanza así:
- Día 1: la podrida inicial contagia a sus vecinas directas.
- Día 2: esas nuevas podridas contagian a las suyas.
- Día 3 y siguientes: la onda sigue expandiéndose hasta cubrir todo el cultivo alcanzable.
En el ejemplo de la clase, el cultivo termina completamente podrido en 4 días. Ese número es lo que retorna la función. Si al terminar la propagación queda al menos una naranja fresca aislada, el resultado es -1 porque ya no hay forma de rescatarla ni de contagiarla.
¿Cuándo se retorna -1 en Rotting Oranges? Cuando, después de propagar la podredumbre todo lo posible, todavía queda al menos una naranja fresca sin vecinos podridos que puedan alcanzarla.
¿Por qué importa el punto de inicio de la podredumbre?
El reto que plantea esta clase es de diseño. Si asumes que solo la naranja de la esquina empieza podrida, tu algoritmo es más simple: arrancas desde un único punto y propagas. Pero el problema real no garantiza esa condición.
En la práctica, puede haber varias naranjas podridas dispersas desde el día cero, y no puedes predecir dónde están. Eso cambia la estrategia: ya no basta con un punto de partida, necesitas procesarlas todas a la vez.
¿Qué estructura de datos conviene usar?
La pista está en la propagación por niveles. Una cola (queue) te permite registrar todas las naranjas podridas iniciales y procesarlas en bloques que representan días completos. Cada vuelta del ciclo equivale a un día de contagio.
- Recorres la matriz una vez para encontrar todas las celdas con valor 2.
- Las metes a la cola como puntos de partida simultáneos.
- Cuentas también cuántas naranjas frescas existen para validar al final si quedaron rezagadas.
Este recorrido inicial es clave: sin él, no sabes si retornar el conteo de días o -1.
¿Qué deberías cambiar en tu solución para casos generales?
Si tu primer intento asumió una sola naranja podrida en la esquina, el ajuste tiene tres frentes claros que vale la pena revisar antes de codificar.
- Procesa todas las naranjas podridas del estado inicial, no solo una.
- Lleva un contador de naranjas frescas para detectar el caso imposible.
- Maneja la propagación por niveles, no por celdas individuales, para que el conteo de días sea exacto.
Con esos tres cambios, tu solución pasa de resolver un caso particular a cubrir cualquier configuración del cultivo. Te invito a comentar qué estructura usarías tú, cómo manejarías el conteo de días y qué optimizaciones agregarías para matrices grandes.