Introducción

1

¿Qué es un grafo?

2

¿Qué es un árbol?

3

¿Qué es recursión?

4

Aplicaciones reales de grafos y árboles

5

Formas de representar un grafo

DFS

6

Análisis de DFS: algoritmo de búsqueda en profundidad

7

Programando DFS de forma recursiva

8

Otras formas de programar DFS

9

Recorridos y profundidad de un Árbol

10

Sum Root to Leaf Numbers: análisis del problema

11

Solución de Sum Root to Leaf Numbers

12

Playground: Sum Root to Leaf Numbers

13

Programando Sum Root to Leaf Numbers en Golang

14

Number of Islands: análisis del problema

15

Solución de Number of Islands

16

Playground: Number of Islands

17

Programando Number of Islands en Python

18

Ejercicios recomendados de DFS

19

Ejercicios resueltos de DFS

BFS

20

Análisis de BFS: algoritmo de búsqueda en anchura

21

Programando BFS con Python

22

Minimum Knights Moves (movimientos de caballo en ajedrez): análisis del problema

23

Solución de Minimum Knights Moves

24

Playground: Minimum Knights Moves

25

Programando Minimum Knights Moves con Python

26

Rotting Oranges: análisis del problema

27

Solución de Rotting Oranges

28

Playground: Rotting Oranges

29

Rotting Oranges con Java

30

Shortest Bridge Between Islands: análisis del problema

31

Solución de Shortest Bridge Between Islands

32

Playground: Shortest Bridge Between Islands

33

Programando Shortest Bridge Between Islands con Python

34

Ejercicios recomendados de BFS

35

Ejercicios resueltos de BFS

Backtrack

36

Algoritmo de Backtrack

37

Letter Combinations of a Phone Number: análisis del problema

38

Solución de Letter Combinations of a Phone Number

39

Programando Letter Combinations of a Phone Number con C++

40

Playground: Letter Combinations of a Phone Number

41

Restore IP Addresses: análisis del problema

42

Programando Restore IP Addresses con C++

43

Playground: Restore IP Addresses

44

Word Search: análisis del problema

45

Solución de Word Search

46

Playgrund: Word Search

47

Programando Word Search JavaScript

48

Reto: N Queens Puzzle

49

Ejercicios recomendados de Backtrack

50

Ejercicios resueltos de Backtrack

Próximos pasos

51

¿Qué otros algoritmos y tipos de grafos puedes aprender?

52

¿Quieres más cursos avanzados de algoritmos?

Convierte tus certificados en títulos universitarios en USA

Antes: $249

Currency
$209

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Suscríbete

Termina en:

16 Días
22 Hrs
1 Min
8 Seg

Ejercicios recomendados de BFS

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