Este documento presenta el algoritmo de Bellman-Ford para encontrar el camino más corto en un grafo dirigido y ponderado. Describe el proceso iterativo de actualización de etiquetas y cómo detecta ciclos de peso negativo. También incluye un ejemplo de código para implementar el algoritmo en un grafo específico.

1. 1
UNIVERSIDAD TECNOLÓGICA DE LOS
ANDES
FACULTAD DE INGENIERÍA
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS E
INFORMÁTICA
ALGORITMOS Y
PROGRAMACION II
ING: GODOFREDO POCCORI UMERES
PRESENTAN:
• MAROCHO HUAMAN ALEXANDER
• HUACAC SOTO ALVARO
• YUPANQUI JARA MARIA EMPERATRIZ
• GAMARRA RODRIGUEZ FRAN FERNANDO
CUSCO-PERU

2. 2
INDICE
1. INTRODUCCIÓN................................................................................................................. 3
2. ALGORITMO DE BELLMAN-FORD............................................................................... 5
3. ALGORITMO ..................................................................................................................... 11
4. CONCLUSIONES ............................................................................................................... 13
5. BIBLIOGRAFÍA ................................................................................................................. 14

3. 3
1. INTRODUCCIÓN
Así como los problemas de los puentes de Königsberg fueron resueltos por Leonhard
Euler nosotros resolvimos este tema basándonos en los pasos que se sigue en un grafo y así
llegar a concluir este trabajo de manera exitosa
El problema de los puentes de Königsberg es un problema matemático resuelto por
Leonhard Euler en 1736 y cuya resolución dio origen a la teoría de grafos. El problema se
formuló en el siglo XVIII y consistía en encontrar un recorrido para cruzar a pie toda la ciudad
pasando solo una vez por cada uno de los puentes y regresando al mismo punto de inicio. La
respuesta es negativa, es decir, no existe una ruta con estas características.
Desarrollado por Richar Bellman, Lester Ford y Samuel Ens . Quienes dicen “Los pesos
negativos no son simplemente una curiosidad matemática, surgen de una forma natural en la
reducción a problemas de caminos más cortos”
Similar a un algoritmo de Dijkstra, el algoritmo de bellman-ford genera el camino más
corto en un grafo dirigido ponderado. El algoritmo de Dijkstra está hecho para resolver el

4. 4
problema con un tiempo menor, pero eso hace como consecuencia de que el grafo no pueda usar
negativos en los valores de las aristas. Debido a ello el algoritmo se vé solo cuando los pesos de
las aristas sean negativos, aunque sea uno solo de ellos.
Estos se han vuelto en un gran ejemplo para la reducción de los problemas en los caminos
hamiltonianos que es de orden de complejidad NP-Completo, siendo los cuales un algoritmo
que a pesar de su utilidad es prácticamente tan complejo que pueden llegar a ser de una
complejidad incluso superior a N²-1.
Otra propiedad de este algoritmo es que si este contiene un ciclo de coste negativo el
algoritmo será capaz de detectarlo, pero no encontrará el camino más corto que no repita ningún
vértice en el proceso.

5. 5
2. ALGORITMO DE BELLMAN-FORD
Para realizar la teoria tomaremos una ejemplo asumiendo el siguiente grafo dirigido con
una nodos A,B,C y D. y respectivas distancias entre ellos:
consecuentemente tendremos una tabla con iteraciones que desconocemos desde un
principio e iremos resolviendo durante el proceso:
K=0 K=1 K=2 K=3 K=4 K=...
A A,0
B A,3
C A,∞
D A,6

6. 6
Donde la distancia se ve inicializada en K=0 desde el punto de origen hasta los todos los
nodos, inclusive si no tienen un peso. De tal forma que de A hasta A hay 0 puesto que es el
mismo nodo, de A hasta B hay 6, de A hasta C hay ∞ puesto que no hay un camino definido y
por ende es infinito y de A hasta D es 6.
A partir de aquí lo que haremos es actualizar las etiquetas con las nuevas distancias que
vamos conociendo una vez hemos inicializado.
Tras inicializar A se quedaría igual se toma el menor número para a desde la suma de sus
diferentes rutas y tomando el menor, para el primer caso Para llegar a B con un peso de 3 o
tomando de a a D con un peso de 2 luego de sumar sus pesos. Para llegar a C la menor ruta
tomando la ruta anterior +2 por su peso sería 5. Para acabar con D quedándose igual puesto que
la ruta menor sigue siendo la misma.

7. 7
Y correspondientemente asignaremos los nuevos valores a la tabla.
K=0 K=1 K=2 K=3 K=4 K=...
A A,0 A,0
B A,3 D,2
C A,∞ B,5
D A,6 A,6
Y repetimos el proceso aclarando que siempre tomaremos la última etiqueta expresada.
Repitiendo tantas veces sea necesario, hasta que K=n tiene que ser igual a K=n-1.

8. 8
K=0 K=1 K=2 K=3 K=4 K=...
A A,0 A,0 A,0
B A,3 D,2 D,2
C A,∞ B,5 B,4
D A,6 A,6 A,6
Como vemos que k=2 y K=1 no se repiten realizaremos el proceso otra vez.

9. 9
K=0 K=1 K=2 K=3 K=4 K=...
A A,0 A,0 A,0 A,0
B A,3 D,2 D,2 D,2
C A,∞ B,5 B,4 B,4
D A,6 A,6 A,6 A,6
Como podemos observar k=2 y K=3 son idénticas, mostrando el final del algoritmo y la
+
Para leer el siguiente cuadro solo habría que analizar la columna deseada, y repitiendolo
iterando en su último resultado.

10. 10
K=0 K=1 K=2 K=3
A A,0 A,0 A,0 A,0
B A,3 D,2 D,2 D,2
C A,∞ B,5 B,4 B,4
D A,6 A,6 A,6 A,6
Por ejemplo si deseamos llegar a C nos ubicamos en la fila C y desplazamos hasta la
última iteración para saber que debemos ir a B con un consumo de 2, luego repetiremos el
proceso para llegar a B por el por D con un consumo de -4 y de D a A con un consumo de 6.
y con eso habría acabado, aclarando que dependiendo del grafo serán más o menos
iteraciones.
En resumen. Este algoritmo puede hallar el camino más corto a pesar de sus valores, pero
está limitado a que necesita completarse para poder ser usado, y el número de operaciones

11. 11
necesarias es exponencial así que no se puede saber cuántas iteraciones son necesarias para
completarlo.
3. ALGORITMO
Para demostrar el código usaremos el mismo grafo que hemos usado en el ejercicio
teórico pero reemplazamos las letras por sus números según el orden que estos tengan en el
alfabeto.
class Grafo:
def __init__(self, NumeroNodos:int):
self.Nodos = NumeroNodos
self.grafo = []
def agregar_arista(self, Origen:int, Destino:int, Peso:int):
self.grafo.append([Origen, Destino, Peso])
def bellman_ford(self, origen:int):
#Inicializar una lista con todos los nodos en infinitos
distancias = [float("inf")] * self.Nodos
#La distancia de si misma es 0
distancias[origen] = 0
# Actualizacion de pesos
for _ in range(self.Nodos - 1):
for O, D, P in self.grafo:
if distancias[O - 1] != float("inf") and distancias[O - 1] + P < distancias[D - 1]:
distancias[D - 1] = distancias[O - 1] + P
# Verificar ciclos de peso negativo
for O, D, P in self.grafo:
if distancias[O - 1] != float("inf") and distancias[O - 1] + P < distancias[D - 1]:
print("El grafo entró en un ciclo de entrada negativo")
return

12. 12
self._imprimir_solucion(distancias)
def _imprimir_solucion(self, distancias):
print("Distancia mínima desde el origen:")
for nodo in range(1, self.Nodos + 1):
print(f"Nodo {nodo}: {distancias[nodo - 1]}")
bf = Grafo(4)
bf.agregar_arista(1, 2, 3)
bf.agregar_arista(1, 4, 6)
bf.agregar_arista(4, 2, -4)
bf.agregar_arista(2, 3, 2)
bf.agregar_arista(3, 4, 3)
bf.bellman_ford(0)
dando como resultado en la terminal

13. 13
4. CONCLUSIONES
El algoritmo de Bellman-Ford es fundamental para la teoría de grafos debido a su
capacidad para encontrar el camino más corto entre dos nodos en un grafo dirigido ponderado.
Su importancia radica en varias propiedades clave que lo hacen versátil y necesario en diversas
aplicaciones.
La capacidad del algoritmo Bellman-Ford para manejar gráficos con pesos negativos lo
distingue de otros algoritmos más especializados. Su capacidad para detectar ciclos de peso
negativos es crítica en situaciones donde el costo asociado con una ventaja puede ser negativo,
evitando así resultados indefinidos o inconsistentes en problemas de optimización.
Además, la versatilidad del algoritmo se refleja en su capacidad para adaptarse a diversas
situaciones, incluida la posibilidad de manejar gráficos que presenten pesos negativos y ciclos de
pesos negativos. Esta capacidad la convierte en una herramienta valiosa en una variedad de
contextos, desde la planificación de rutas en sistemas de transporte hasta la optimización de
redes informáticas.

14. 14
5. BIBLIOGRAFÍA
Algoritmo de Bellman, R. (11 de ene de 2021). wikipedia. Obtenido de wikipedia:
https://es.wikipedia.org/w/index.php?title=Algoritmo_de_Bellman-
Ford&oldid=132302116
Benigno, S. S. (7 de 07 de 22). Ediciones Paraninfo, S.A. Obtenido de
https://www.paraninfo.es/catalogo/9788413679280/teoria-de-grafos-y-modelizacion--
problemas-resueltos
Goldberg, A. V. (3 de 6 de 1993). ScienceDirec. Obtenido de
https://doi.org/10.1016/0893-9659(93)90022-f