Cristian López-Ivan Ochoa-Nicolas López

Taller

!pip intall pulp

def dijkstra(grafo, nodo_inicial, nodo_final):
"""
Encuentra la ruta más corta entre los nodos en un grafo ponderado
usando el algoritmo de Dijkstra.

Parámetros:
grafo: Un diccionario que representa el grafo, donde las claves
son los nodos y los valores son diccionarios con los nodos adyacentes
y sus pesos.
nodo_inicial: El nodo inicial.
nodo_final: El nodo final.

Retorno:
Una tupla que contiene la distancia mínima y la ruta más corta del
nodo inicial al nodo final.
"""

# Inicializar las distancias, la lista de nodos no visitados y el

diccionario de predecesores.
predecesores = {}
distancias = {nodo: float('inf') for nodo in grafo}
distancias[nodo_inicial] = 0
no_visitados = set(grafo.keys())

# Bucle principal del algoritmo.

while no_visitados:
# Seleccionar el nodo no visitado con la distancia mínima.
nodo_actual = min(no_visitados, key=distancias.get)

# Si el nodo actual es el nodo final, se ha encontrado la ruta más

corta.
if nodo_actual == nodo_final:
return distancias[nodo_final], reconstruir_ruta(nodo_inicial,
nodo_actual, predecesores)

# Marcar el nodo actual como visitado.

no_visitados.remove(nodo_actual)

# Para cada adyacente del nodo actual:

for adyacente, peso in grafo[nodo_actual].items():
Cristian López-Ivan Ochoa-Nicolas López

# Si el adyacente no está visitado:

if adyacente in no_visitados:
# Calcular la distancia total al adyacente.
distancia_total = distancias[nodo_actual] + peso

# Si la distancia total es menor que la distancia actual al

adyacente, actualizar la distancia del adyacente.
if distancia_total < distancias[adyacente]:
distancias[adyacente] = distancia_total
predecesores[adyacente] = nodo_actual

# Si se llega a este punto, no hay ruta entre el nodo inicial y el

nodo final.
return float('inf'), None

def reconstruir_ruta(nodo_inicial, nodo_final, predecesores):

"""
Reconstruye la ruta más corta del nodo inicial al nodo final a
partir de los predecesores.

Parámetros:
nodo_inicial: El nodo inicial.
nodo_final: El nodo final.
predecesores: Un diccionario que mapea cada nodo a su predecesor
en la ruta más corta.

Retorno:
Una lista que representa la ruta más corta del nodo inicial al
nodo final.
"""

ruta = []
nodo_actual = nodo_final
while nodo_actual != nodo_inicial:
ruta.append(nodo_actual)
nodo_actual = predecesores[nodo_actual]
ruta.append(nodo_inicial)
ruta.reverse()
return ruta

# Ejemplo de uso
grafo = {
"A": {"B": 4, "C": 9, "D": 10},
Cristian López-Ivan Ochoa-Nicolas López

"B": {"A": 4, "D": 8, "E": 12},

"C": {"A": 9, "D": 14},
"D": {"A": 10, "B": 8, "C": 14, "E": 16},
"E": {"B": 12, "D": 16}
}

nodo_ionicial = "A"
nodo_final = "E"

distancia, ruta = dijkstra(grafo, nodo_inicial, nodo_final)

print(f"Distancia mínima dada: {distancia}")

print(f"Ruta más corta dada: {ruta}")

2.

1) (o-a-c-e-g-d)
2) (o.i-n-k-d