- 1

Grafos y Árboles: Estructuras de Datos Avanzadas
06:48 - 2

Estructuras de Datos: Introducción a Árboles y Sus Propiedades
07:12 - 3

Recursión: Concepto y Aplicaciones Prácticas con Ejemplos
09:11 - 4

Aplicaciones Prácticas de Grafos en Tecnología e Industria
05:16 - 5
Representación de Grafos: Matriz y Lista de Adyacencia
01:02
Construcción de Puentes Cortos entre Islas en Matrices Binarias
Clase 30 de 52 • Curso de Algoritmos Avanzados: Grafos y Árboles
Contenido del curso
- 6

Búsqueda en Profundidad (DFS) en Árboles y Grafos
04:50 - 7

Implementación de DFS recursivo para búsqueda en árboles
12:10 - 8
Búsqueda en Profundidad (DFS) para Grafos: Enfoque Iterativo y Recursivo
01:27 - 9

Recorridos y Profundidad en Árboles Binarios y Enearios
07:09 - 10

Suma de Caminos en Árboles Binarios
02:05 - 11

Suma de Números de Raíz a Hoja en Árboles
07:32 - 12
Playground: Sum Root to Leaf Numbers
00:00 - 13

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

Resolución del Problema de Número de Islas con DFS
02:32 - 15

Conteo de Islas en Matrices con DFS
08:51 - 16
Playground: Number of Islands
00:00 - 17

Implementación de "Número de Islas" con Recursión en Python
10:18 - 18
Ejercicios Prácticos de Búsqueda en Profundidad (DFS)
02:22 - 19
Algoritmos de Búsqueda en Profundidad (DFS) en Problemas Comunes
06:19
- 20

Algoritmo BFS: Recorrido en Anchura de Grafos y Árboles
02:05 - 21

Implementación de BFS en Árboles usando Python
08:43 - 22

Movimiento mínimo de caballo en ajedrez infinito
02:55 - 23

Resolviendo el Problema Mínimo de Movimiento del Caballo en Ajedrez
08:11 - 24
Playground: Minimum Knights Moves
00:00 - 25

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

Propagación de Plagas en Cultivos: Cálculo de Días para Contagio Total
03:50 - 27

Resolución de Rotting Oranges usando BFS
08:44 - 28
Playground: Rotting Oranges
00:00 - 29

Propagación de Plagas en Matrices usando BFS en Java
23:44 - 30

Construcción de Puentes Cortos entre Islas en Matrices Binarias
03:39 - 31

Resolución del Problema Shortest Bridge con DFS y BFS
07:36 - 32
Playground: Shortest Bridge Between Islands
00:00 - 33

Búsqueda del camino más corto entre islas usando BFS en Python
14:58 - 34
Búsqueda en anchura: Ejercicios prácticos y aplicaciones
03:41 - 35
Ejercicios avanzados de búsqueda en anchura (BFS) en programación
08:47
- 36

Algoritmo Backtracking: Solución de Problemas Complejos
04:21 - 37

Combinaciones de Letras en Números Telefónicos
01:52 - 38

Combinaciones de Letras a partir de un Número de Teléfono
09:20 - 39

Generación de combinaciones de letras con teclados numéricos en C++
14:08 - 40
Playground: Letter Combinations of a Phone Number
00:00 - 41

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

Generación de IPs válidas con backtracking en C++
28:17 - 43
Playground: Restore IP Addresses
00:00 - 44

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

Búsqueda de Palabras en Matrices usando Backtracking y DFS
08:31 - 46
Playgrund: Word Search
00:00 - 47

Implementación de búsqueda de palabras en matrices con DFS en JavaScript
18:19 - 48
Resolución del problema de las n reinas en ajedrez
01:08 - 49
Ejercicios de Backtracking: Combinaciones y Permutaciones
01:05 - 50
Combinaciones y Permutaciones con Backtracking
02:14
¿Cómo resolver el problema del puente más corto entre islas?
El problema del que hablamos consiste en encontrar la forma más eficiente de crear un puente entre dos islas en una matriz binaria. Te enfrentas a un nuevo desafío: hallar la mínima distancia necesaria para conectar dos islas, representadas por grupos de celdas adyacentes de unos, rodeadas de celdas de ceros que representan agua. Vamos a desglosar cómo podrías abordar este problema con tus habilidades de programación.
¿Qué es una isla?
- Una isla está compuesta por celdas adyacentes de unos ('1') que forman un bloque de tierra.
- Deben estar rodeadas por celdas de ceros ('0'), simbolizando el agua.
- Pueden tener cualquier forma, lo que complejiza encontrar el punto óptimo para el puente.
¿Cómo encontrar la menor distancia para construir el puente?
El objetivo es encontrar los extremos de las islas que están más cerca entre ellas, de modo que se minimice el "puente" de celdas de ceros necesario para conectar las islas. Te invito a reflexionar sobre cómo puedes usar soluciones previas. En particular, podrías reutilizar elementos del código usado para identificar el número de islas y adaptarlo a este nuevo contexto.
Ejemplo práctico
Imagina un anillo formado por una isla rodeando otra isla central. Aquí, puesto que cada punto límite de la isla externa está equidistante de la interna, varias soluciones pueden ser igualmente válidas. Podemos considerar estas situaciones:
- Distancias iguales: Cuando las islas son equidistantes en todos los puntos, el resultado sería 1, pues cualquier puente tendrá la misma longitud mínima.
- Formas irregulares: Podrías enfrentarte a islas con formas inusuales, donde necesitas identificar los puntos óptimos para el puente, a menudo implicando una mayor complejidad de cálculo.
¿Cómo reutilizar partes del código del problema anterior?
Para avanzar, considera cómo utilizaste algoritmos de búsqueda en el problema de 'número de islas'. Podrías:
- Emplear Depth First Search (DFS) o Breadth First Search (BFS) para identificar las islas.
- Modificar estos métodos para buscar la menor distancia posible entre los bordes de las islas.
Al implementar estos conceptos, comparto un fragmento de código que podrías considerar:
# Ejemplo para BFS en Python
from collections import deque
def bfs_shortest_bridge(grid):
# Inicializa cola para BFS y aplica búsqueda inicial para una isla
queue = deque()
for i in range(len(grid)):
for j in range(len(grid[0])):
if grid[i][j] == 1:
dfs_mark_island(grid, i, j, queue)
break
if queue:
break
# Expande el puente usando BFS
steps = 0
directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
while queue:
size = len(queue)
for _ in range(size):
x, y = queue.popleft()
for dx, dy in directions:
nx, ny = x + dx, y + dy
if 0 <= nx < len(grid) and 0 <= ny < len(grid[0]):
if grid[nx][ny] == 1:
return steps
elif grid[nx][ny] == 0:
grid[nx][ny] = -1 # Marcar el agua expandida
queue.append((nx, ny))
steps += 1
return -1
def dfs_mark_island(grid, i, j, queue):
if i < 0 or i >= len(grid) or j < 0 or j >= len(grid[0]) or grid[i][j] != 1:
return
grid[i][j] = -1 # Marcar como visitado
queue.append((i, j))
for di, dj in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
dfs_mark_island(grid, i + di, j + dj, queue)
Este fragmento ilustra cómo identificar una isla y luego usar BFS para encontrar la distancia mínima del puente. Al ejecutar el código, buscas el camino más corto entre las islas, mejorando la eficiencia de materiales necesarios para construirlo.
Motívate a resolver el problema
Si ya tienes una idea, te animo a que intentes resolverlo por ti mismo. Usa lo aprendido anteriormente, adapta el código a tus necesidades y comparte tus experiencias y soluciones en la sección de comentarios. ¡Continúa aprendiendo y mejorando tus habilidades!