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
03:50 min - 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
Viendo ahora - 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
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:
- 'M' representa una mina no revelada,
- 'E' representa una casilla vacía no revelada,
- 'B' representa un cuadrado vacío revelado que no tiene minas adyacentes (es decir, arriba, abajo, izquierda, derecha y las 4 diagonales) el dígito ('1' a '8') representa cuántas minas están adyacentes a esta casilla revelada.
- 'X' representa una mina revelada.
También se le da un array entero click donde click = [clickr, clickc] representa la siguiente posición de click entre todas las casillas no reveladas ('M' o 'E'). Devuelve el tablero después de revelar esta posición de acuerdo con las siguientes reglas:
- Si se revela una mina 'M', entonces el juego ha terminado. Debes cambiarla por una 'X'.
- Si se revela una casilla vacía "E" sin minas adyacentes, entonces cámbiala por una "B" revelada y todas sus casillas adyacentes no reveladas deben ser reveladas recursivamente.
- Si se revela una casilla vacía "E" con al menos una mina adyacente, entonces cámbiala por un dígito ("1" a "8") que represente el número de minas adyacentes.
Devuelve el tablero cuando no se revelen más casillas.
Vuelos más baratos con K paradas Hay n ciudades conectadas por un cierto número de vuelos. Se le da un array flights donde flights[i] = [fromi, toi, pricei] indica que hay un vuelo desde la ciudad fromi a la ciudad toi con un precioi. También se le dan tres enteros src, dst y k, devuelve el precio más barato de src a dst con un máximo de k paradas. Si no existe tal ruta, devuelve -1.
Ejemplo 1: Entrada:
- n = 4
- vuelos = [[0,1,100],[1,2,100],[2,0,100],[1,3,600],[2,3,200]]
- src = 0
- dst = 3
- k = 1 Salida: 700
Explicación:El gráfico se muestra arriba. El camino óptimo, con un máximo de 1 parada, desde la ciudad 0 a la 3 está marcado en rojo y tiene un coste de 100 + 600 = 700. Nótese que el camino que pasa por las ciudades [0,1,2,3] es más barato pero no es válido porque utiliza 2 paradas.
Juego Escalera y Serpientes Se le da un tablero de matriz entera n x n en el que las casillas están etiquetadas de 1 a n2 al estilo Boustrophedon empezando por la parte inferior izquierda del tablero (es decir, tablero[n - 1][0]) y alternando la dirección de cada fila. Se comienza en la casilla 1 del tablero. En cada movimiento, partiendo de la casilla curr, haz lo siguiente Elige una casilla de destino próxima con una etiqueta en el rango [curr + 1, min(curr + 6, n2)]. Esta elección simula el resultado de una tirada estándar de 6 caras: es decir, siempre hay como máximo 6 destinos, independientemente del tamaño del tablero. Si el siguiente tiene una serpiente o escalera, debes moverte al destino de esa serpiente o escalera. En caso contrario, te mueves a siguiente.
El juego termina cuando se llega a la casilla n2. Una casilla del tablero en la fila r y la columna c tiene una serpiente o escalera si tablero[r][c] != -1. El destino de esa serpiente o escalera es el tablero[r][c]. Las casillas 1 y n2 no tienen serpiente o escalera. Ten en cuenta que sólo puedes coger una serpiente o escalera como máximo una vez por movimiento. Si el destino de una serpiente o escalera es el inicio de otra serpiente o escalera, no sigues la siguiente serpiente o escalera. Por ejemplo, suponga que el tablero es [[-1,4],[-1,3]], y en el primer movimiento, su casilla de destino es la 2. Sigue la escalera hasta la casilla 3, pero no sigue la escalera posterior hasta la 4. Devuelve el menor número de movimientos necesarios para llegar a la casilla n2. Si no es posible llegar a la casilla, devuelve -1.
Ejemplo 1: Entrada: board=[[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,35,-1,-1,13,-1],[-1,-1,-1,-1,-1,-1],[-1,15,-1,-1,-1,-1]] Salida: 4
Explicación: Al principio, empiezas en la casilla 1 (en la fila 5, columna 0). Decides moverte a la casilla 2 y debes llevar la escalera hasta la casilla 15. Luego decides moverte a la casilla 17 y debes llevar la serpiente a la casilla 13. Luego decides moverte a la casilla 14 y debes llevar la escalera a la casilla 35. Entonces decides moverte a la casilla 36, terminando el juego. Este es el menor número posible de movimientos para llegar a la última casilla, así que devuelve 4.
Horario del Curso Hay un total de numCursos cursos que tiene que tomar, etiquetados de 0 a numCursos - 1. Se le da una matriz prerrequisitos donde prerrequisitos[i] = [ai, bi] indica que debe tomar el curso bi primero si quiere tomar el curso ai. Por ejemplo, el par [0, 1], indica que para tomar el curso 0 hay que tomar primero el curso 1. Devuelve true si puedes terminar todos los cursos. En caso contrario, devuelve false.
Ejemplo 1: Entrada: numCursos = 2, prerrequisitos = [[1,0]] Salida: true Explicación: Hay un total de 2 cursos para tomar. Para tomar el curso 1 debes haber terminado el curso 0. Así que es posible.
Búsqueda en anchura: Ejercicios prácticos y aplicaciones