Resolver el problema de las naranjas podridas con BFS en Java te enseña a manejar matrices, colas y propagación por niveles. Aquí traduces la lógica a código paso a paso, validando casos límite y entendiendo por qué cada estructura importa para contar los días hasta que todo el cultivo se pudra.

¿Por qué validar casos borde antes de aplicar BFS?

Antes de tocar la cola, tu función debe blindarse contra entradas vacías y escenarios donde el algoritmo no aporta valor. Si la matriz es null o tiene longitud cero, retornas cero porque no hay nada que pudrir [00:38].

Luego viene un caso más sutil: cuando hay plantas frescas aisladas por espacios vacíos sin conexión con ninguna planta podrida. Por mucho que propagues, esas frutas se quedan sanas para siempre, así que el resultado debe ser -1.

¿Qué hace BFS en este problema? Recorre el cultivo por niveles desde cada naranja podrida inicial, contaminando vecinos adyacentes en cada iteración. Cada nivel equivale a un día completo de propagación.

¿Cómo inicializar la cola y contar frutas frescas?

El primer recorrido por la matriz tiene dos misiones simultáneas: encolar todas las posiciones de naranjas ya podridas y llevar la cuenta de las frescas. Iteras con dos for anidados sobre cultivo.length y cultivo[0].length, lo que te da una complejidad temporal de O(n²) en esta fase [03:55].

• Si cultivo[i][j] == 2, agregas la pareja (i, j) a la cola con cola.offer(...).
• Si cultivo[i][j] == 1, incrementas la variable cantidadFrescas.
• Si es cero, lo ignoras porque representa un espacio vacío.

Aquí aparece otro atajo de eficiencia: si después de iterar cantidadFrescas ya es cero, significa que todas las naranjas llegaron podridas desde el inicio. Retornas cero días sin ejecutar BFS [06:30].

¿Por qué usar una linked list como cola en Java?

Java ofrece la interfaz Queue implementada por LinkedList, ideal porque mantiene el orden FIFO que necesita BFS. Cada elemento es una pareja de enteros con coordenadas x e y, y avanzas por niveles porque cada nivel representa un día de propagación.

¿Cómo programar el bucle BFS y propagar la podredumbre?

Declaras un contador dias = 0 y un arreglo de direcciones con los cuatro lados: arriba, abajo, izquierda, derecha. Esa estructura es clave porque te permite extender el algoritmo: si quisieras incluir diagonales o movimientos tipo caballo de ajedrez, solo agregas pares al arreglo sin tocar la lógica [07:50].

El bucle principal se ejecuta while (!cola.isEmpty()). Dentro, primero incrementas dias++ y luego iteras exactamente sobre cola.size() elementos del nivel actual. Es fundamental capturar ese tamaño antes del for interno, porque la cola crecerá conforme agregues nuevas posiciones contaminadas.

Para cada posición que sacas con cola.poll(), recorres las cuatro direcciones y calculas las coordenadas siguientes:

• Verificas que nuevaX y nuevaY estén dentro de los límites de la matriz.
• Confirmas que la celda no sea ya un dos (planta podrida).
• Si es una planta sana, la marcas como 2, la encolas y restas uno a cantidadFrescas.

¿Por qué se resta uno al total de días al final? Porque el último nivel del BFS no representa un día adicional de propagación, sino la verificación de que ya no hay más vecinos por contaminar. Por eso retornas dias - 1.

¿Cómo decidir entre retornar los días o menos uno?

Al salir del while, evalúas cantidadFrescas. Si es cero, todas las naranjas se pudrieron y retornas dias - 1. Si quedó algún valor mayor a cero, significa que existen plantas aisladas sin conexión posible y retornas -1 para indicar que el escenario es imposible.

¿Qué habilidades técnicas refuerza esta implementación?

Más allá de la sintaxis de Java, este ejercicio consolida varias competencias del pensamiento algorítmico que se transfieren a cualquier lenguaje.

• Manejo de estructuras de datos tipo cola con LinkedList y operaciones offer y poll [09:10].
• Recorrido de matrices con doble índice y validación de límites antes de acceder a celdas vecinas.
• Diseño de algoritmos por niveles, donde cada iteración del while externo equivale a una unidad de tiempo del problema.
• Identificación de casos especiales como entradas vacías, tableros completamente podridos o frutas aisladas, lo que te ahorra cómputo y previene errores.

La parte más subestimada del proceso son las pruebas de escritorio. Cuando escribes el código tú mismo y sigues línea por línea cómo cambian los valores, conceptos abstractos como la propagación por niveles se vuelven tangibles. Por eso vale la pena programarlo en tu lenguaje preferido (Python, JavaScript, C++) y compartir tu versión en los comentarios para comparar enfoques con la comunidad.

¿Cómo lo implementaste tú? Comparte tu solución y los casos borde que detectaste, así aprendemos entre todos qué prácticas replicar y cuáles evitar.