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
Viendo ahora - 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
03:41 min - 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
Suma de caminos raíz a hoja en árboles
Resumen
Si te enfrentas al problema Sum Root to Leaf Numbers, lo primero que necesitas dominar es cómo se construyen los números a partir de los caminos entre la raíz y las hojas de un árbol binario. Este reto, común en entrevistas técnicas y plataformas como LeetCode, pone a prueba tu manejo de recorridos en árboles y tu capacidad de traducir jerarquía en valores numéricos.
¿Qué pide el problema Sum Root to Leaf Numbers?
El enunciado entrega la raíz de un árbol binario cuyos nodos contienen únicamente dígitos del cero al nueve. Tu tarea es devolver la suma total de todos los números formados por los caminos que van desde la raíz hasta cada nodo hoja.
La clave está en cómo se forma cada número. Mientras más arriba esté un nodo en la jerarquía del árbol, más a la izquierda quedará su dígito dentro del número final. Es decir, la raíz aporta el dígito más significativo y la hoja aporta el menos significativo.
¿Qué es un nodo hoja en un árbol binario? Es un nodo que no tiene hijos, ni izquierdo ni derecho. Marca el final de un camino dentro del árbol.
¿Cómo se forman los números entre raíz y hoja?
Imagina un árbol muy sencillo con la raíz 1, un hijo izquierdo 2 y un hijo derecho 3. Aquí tienes dos caminos posibles desde la raíz hasta una hoja [0:34].
- Camino izquierdo: 1 seguido de 2 forma el número 12.
- Camino derecho: 1 seguido de 3 forma el número 13.
- Suma final: 12 + 13 = 25.
Ese 25 es exactamente lo que debes retornar. Y aquí viene lo interesante: si el árbol creciera y debajo del 2 apareciera otro 3, el camino ya no sería 12, sino 123, porque cada nivel adicional desplaza los dígitos anteriores hacia la izquierda.
¿Por qué la jerarquía define el valor del dígito?
Piensa en cómo lees un número de varias cifras. El dígito de la izquierda vale más que el de la derecha. En el árbol pasa lo mismo: la raíz ocupa la posición más alta y, conforme bajas hacia las hojas, vas concatenando dígitos a la derecha. Por eso un camino de tres nodos genera un número de tres cifras.
¿Qué entrada y qué salida espera la función?
La firma del problema es directa y conviene tenerla clara antes de programar.
- Entrada: la raíz del árbol binario, es decir, un único nodo desde el cual puedes recorrer toda la estructura.
- Salida: un entero que representa la suma de todos los números formados por los caminos raíz a hoja.
- Restricción de valores: cada nodo contiene solo dígitos del 0 al 9, lo que garantiza que la concatenación produce números válidos.
¿Qué se retorna en Sum Root to Leaf Numbers? Un solo entero: la suma de todos los números construidos al recorrer cada camino completo desde la raíz hasta una hoja.
¿Qué herramientas del curso puedes aplicar para resolverlo?
Antes de saltar a una solución, vale la pena que pienses qué recursos previos encajan aquí. Los árboles binarios se prestan a recorridos recursivos, y este problema en particular tiene un patrón muy típico: arrastrar un valor acumulado mientras desciendes por cada rama.
Algunas pistas para tu análisis:
- Identifica cuándo un nodo es hoja, porque ahí cierras el número y lo sumas al total.
- Piensa cómo transformar el acumulado al bajar un nivel. Multiplicar por 10 y sumar el dígito actual suele ser el truco.
- Decide si prefieres recursión, una pila explícita o un recorrido en anchura.
¿Qué enfoque usarías tú? Déjame en los comentarios tu análisis, las estructuras que considerarías y el pseudocódigo que tienes en mente. En la siguiente clase reviso una posible solución para que la compares con la tuya.