Introducción

1

Grafos y Árboles: Estructuras de Datos Avanzadas

2

Estructuras de Datos: Introducción a Árboles y Sus Propiedades

3

Recursión: Concepto y Aplicaciones Prácticas con Ejemplos

4

Aplicaciones Prácticas de Grafos en Tecnología e Industria

5

Representación de Grafos: Matriz y Lista de Adyacencia

DFS

6

Búsqueda en Profundidad (DFS) en Árboles y Grafos

7

Implementación de DFS recursivo para búsqueda en árboles

8

Búsqueda en Profundidad (DFS) para Grafos: Enfoque Iterativo y Recursivo

9

Recorridos y Profundidad en Árboles Binarios y Enearios

10

Suma de Caminos en Árboles Binarios

11

Suma de Números de Raíz a Hoja en Árboles

12

Playground: Sum Root to Leaf Numbers

13

Implementación de Algoritmo DFS en Árboles Binarios con Golang

14

Resolución del Problema de Número de Islas con DFS

15

Conteo de Islas en Matrices con DFS

16

Playground: Number of Islands

17

Implementación de "Número de Islas" con Recursión en Python

18

Ejercicios Prácticos de Búsqueda en Profundidad (DFS)

19

Algoritmos de Búsqueda en Profundidad (DFS) en Problemas Comunes

BFS

20

Algoritmo BFS: Recorrido en Anchura de Grafos y Árboles

21

Implementación de BFS en Árboles usando Python

22

Movimiento mínimo de caballo en ajedrez infinito

23

Resolviendo el Problema Mínimo de Movimiento del Caballo en Ajedrez

24

Playground: Minimum Knights Moves

25

Resolución de Problemas de Caballos de Ajedrez con BFS en Python

26

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

27

Resolución de Rotting Oranges usando BFS

28

Playground: Rotting Oranges

29

Propagación de Plagas en Matrices usando BFS en Java

30

Construcción de Puentes Cortos entre Islas en Matrices Binarias

31

Resolución del Problema Shortest Bridge con DFS y BFS

32

Playground: Shortest Bridge Between Islands

33

Búsqueda del camino más corto entre islas usando BFS en Python

34

Búsqueda en anchura: Ejercicios prácticos y aplicaciones

35

Ejercicios avanzados de búsqueda en anchura (BFS) en programación

Backtrack

36

Algoritmo Backtracking: Solución de Problemas Complejos

37

Combinaciones de Letras en Números Telefónicos

38

Combinaciones de Letras a partir de un Número de Teléfono

39

Generación de combinaciones de letras con teclados numéricos en C++

40

Playground: Letter Combinations of a Phone Number

41

Generación de Direcciones IP Válidas a partir de Cadenas Numéricas

42

Generación de IPs válidas con backtracking en C++

43

Playground: Restore IP Addresses

44

Búsqueda de Palabras en Matrices: Solución y Complejidad

45

Búsqueda de Palabras en Matrices usando Backtracking y DFS

46

Playgrund: Word Search

47

Implementación de búsqueda de palabras en matrices con DFS en JavaScript

48

Resolución del problema de las n reinas en ajedrez

49

Ejercicios de Backtracking: Combinaciones y Permutaciones

50

Combinaciones y Permutaciones con Backtracking

Próximos pasos

51

Algoritmos de Grafos: MIN/MAX-HIP, TRI, Topological Sort y Dijkstra

52

Algoritmos y Estructuras de Datos en la Ingeniería

Búsqueda en anchura: Ejercicios prácticos y aplicaciones

34/52

Lectura

Ejercicios recomendados de BFS

Buscaminas
¡Juguemos al juego del buscaminas!
Se le da un tablero de matriz de m x n caracteres que representa el tablero de juego donde:

...

Regístrate o inicia sesión para leer el resto del contenido.

Aportes 2

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Mi solución del problema de buscaminas ```python from collections import deque def actualizarTablero(tablero, clic): fila, columna = clic if tablero[fila][columna] == 'M': tablero[fila][columna] = 'X' else: bfs(tablero, fila, columna) return tablero def bfs(tablero, fila_inicio, columna_inicio): cola = deque([(fila_inicio, columna_inicio)]) while cola: fila, columna = cola.popleft() if tablero[fila][columna] == 'E': minas = contarMinas(tablero, fila, columna) if minas == 0: tablero[fila][columna] = 'B' for i in range(fila - 1, fila + 2): for j in range(columna - 1, columna + 2): if 0 <= i < len(tablero) and 0 <= j < len(tablero[0]): cola.append((i, j)) tablero[i][j] = 'B' # Marcar como visitado else: tablero[fila][columna] = str(minas) def contarMinas(tablero, fila, columna): minas = 0 for i in range(fila - 1, fila + 2): for j in range(columna - 1, columna + 2): if 0 <= i < len(tablero) and 0 <= j < len(tablero[0]) and tablero[i][j] == 'M': minas += 1 return minas # Ejemplo de uso tablero = [ ['E', 'E', 'E', 'E', 'E'], ['E', 'E', 'M', 'E', 'E'], ['E', 'E', 'E', 'E', 'E'], ['E', 'E', 'E', 'E', 'E'] ] clic = [3, 0] resultado = actualizarTablero(tablero, clic) for fila in resultado: print(fila) ```from collections import deque def actualizarTablero(tablero, clic): fila, columna = clic if tablero\[fila]\[columna] == 'M': \# Caso 1: Mina revelada, el juego termina tablero\[fila]\[columna] = 'X' else: \# Caso 2: Casilla vacía revelada, utilizar BFS bfs(tablero, fila, columna) return tablero def bfs(tablero, fila\_inicio, columna\_inicio): cola = deque(\[(fila\_inicio, columna\_inicio)]) while cola: fila, columna = cola.popleft() if tablero\[fila]\[columna] == 'E': minas = contarMinas(tablero, fila, columna) if minas == 0: \# Caso 2.1: Casilla vacía sin minas adyacentes tablero\[fila]\[columna] = 'B' for i in range(fila - 1, fila + 2): for j in range(columna - 1, columna + 2): if 0 <= i < len(tablero) and 0 <= j < len(tablero\[0]): cola.append((i, j)) tablero\[i]\[j] = 'B' # Marcar como visitado else: \# Caso 2.2: Casilla vacía con al menos una mina adyacente tablero\[fila]\[columna] = str(minas) def contarMinas(tablero, fila, columna): minas = 0 for i in range(fila - 1, fila + 2): for j in range(columna - 1, columna + 2): if 0 <= i < len(tablero) and 0 <= j < len(tablero\[0]) and tablero\[i]\[j] == 'M': minas += 1 return minas \# Ejemplo de uso tablero = \[ \['E', 'E', 'E', 'E', 'E'], \['E', 'E', 'M', 'E', 'E'], \['E', 'E', 'E', 'E', 'E'], \['E', 'E', 'E', 'E', 'E'] ] clic = \[3, 0] resultado = actualizarTablero(tablero, clic) for fila in resultado: print(fila)

Les comparto mi solución del problema de serpientes y escaleras.

def a_numero(actual: tuple[int], filas: int, columnas: int) -> int:
    f, c = actual
    filas_anteriores = filas - 1 - f
    direccion_actual = 1 if (filas-f)%2 == 1 else -1 # 1 a izq, -1 a der
    columnas_anteriores = c+1 if direccion_actual == 1 else columnas-c

    return filas_anteriores * columnas + columnas_anteriores

def a_posicion(numero: int, filas: int, columnas: int) -> tuple[int]:
    filas_anteriores = int((numero-1) / columnas)
    fila = filas - 1 - filas_anteriores
    direccion = 1 if (filas-fila)%2 == 1 else -1 # 1 a izq, -1 a der
    columnas_anteriores = (numero-1) % columnas
    columna = columnas_anteriores if direccion == 1 else columnas-1-columnas_anteriores

    return (fila, columna)

def serpientes_escaleras(tablero: list[list[int]]) -> int:
    ROWS, COLS = len(tablero), len(tablero[0])
    n2 = ROWS * COLS

    cola = [(ROWS-1, 0)]
    num_pasos  = 0

    while cola:
        for _ in range(len(cola)):
            actual = cola.pop(0)
            actual_numero = a_numero(actual, ROWS, COLS)
            posibles_pasos = range(1,7)

            for paso in posibles_pasos:
                nuevo_numero = actual_numero + paso
                if nuevo_numero < n2:
                    f, c = a_posicion(nuevo_numero, ROWS, COLS)
                    valor_casilla = tablero[f][c]
                    if valor_casilla == -1:
                        cola.append((f, c))
                    else:
                        cola.append(a_posicion(valor_casilla, ROWS, COLS))
                else:
                    return num_pasos+1
        num_pasos += 1

    return -1