![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](https://image.slidesharecdn.com/algoritmos1-231116122404-11ab4db1/85/Algoritmo-de-Bellman-Ford-11-320.jpg)
![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](https://image.slidesharecdn.com/algoritmos1-231116122404-11ab4db1/85/Algoritmo-de-Bellman-Ford-12-320.jpg)
Algoritmo de Bellman- Ford
- 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