|
|
import networkx as nx
|
|
|
import matplotlib.pyplot as plt
|
|
|
import numpy as np
|
|
|
|
|
|
|
|
|
#! H=nx.Graph() #cr ́ee un graphe
|
|
|
#! H.add_edge(0,1) #ajoute une arˆete entre les sommets 0 et 1
|
|
|
#! H.add_edges_from([(3,0),(3,4)]) #ajoute les arˆetes d’une liste donn ́ee
|
|
|
#! H.add_node("toto") #ajoute un sommet nomm ́e "toto"
|
|
|
#! H.remove_node(s) #supprime le sommet s
|
|
|
#! H.nodes #sommets du graphe (attention, pour en faire
|
|
|
#! # une vraie liste Python, ́ecrire: list(H.nodes))
|
|
|
#! H.edges #arˆetes du graphe (attention, pour en faire
|
|
|
#! # une vraie liste Python, ́ecrire: list(H.edges))
|
|
|
#! H.edges(s) #les arˆetes qui touchent le sommet s
|
|
|
#! H.neighbors(s) #un it ́erateur sur les voisins du sommet s dans H
|
|
|
#! # pour obtenir une liste, ́ecrire: list(H.neighbors(s))
|
|
|
#! H.nodes[s]["attri"] #acc`ede `a l’attribut nomm ́e "attri" du sommet s
|
|
|
#! # (tant en lecture qu’en ́ecriture)
|
|
|
#! # exemple: H.nodes[s]["attri"]=2
|
|
|
#! # ou alors print(H.nodes[s]["attri"])
|
|
|
|
|
|
# Exercice 1
|
|
|
|
|
|
##################################
|
|
|
##Un graphe pour tester Dijkstra
|
|
|
###################################
|
|
|
print("Un graphe pour tester Dijkstra")
|
|
|
G=nx.Graph()
|
|
|
G.add_nodes_from(["A","B","C","D","E","F","G","H","I","J"],distance=None)
|
|
|
print(G.nodes())
|
|
|
G.add_edges_from([("A", "B", {"weight": 4}),("A", "C", {"weight": 2}),
|
|
|
("A", "E", {"weight": 1}),("B", "F", {"weight": 3}),
|
|
|
("C", "G", {"weight": 1}),("C", "H", {"weight": 2}),
|
|
|
("D", "H", {"weight": 1}),("E", "J", {"weight": 5}),
|
|
|
("F", "I", {"weight": 2}),("I", "J", {"weight": 5}),
|
|
|
("H", "J", {"weight": 6})])
|
|
|
print(G.edges())
|
|
|
#########################
|
|
|
print(G.edges[("A","B")]["weight"])
|
|
|
print(G.nodes["A"]["distance"])
|
|
|
#########################
|
|
|
|
|
|
#? 1.
|
|
|
# On rappelle ci-dessous l’algorithme de Dijkstra qui calcule les distances `a un sommet
|
|
|
# source donn ́e :
|
|
|
# Algorithme de Dijkstra pour le graphe G `a partir du sommet source s
|
|
|
# • L repr ́esentera la fronti`ere. Contient initialement seulement s.
|
|
|
# • La valeur de distance d est initialis ́ee `a d(s)=0 et `a d(v)=∞ pour
|
|
|
# chaque autre sommet v
|
|
|
# • Une liste T contient les sommets qui ont ́et ́e compl`etement trait ́es.
|
|
|
# Initialement T est vide.
|
|
|
# • Tant que L n’est pas vide :
|
|
|
# ⋆ choisir un sommet v dans L qui a une valeur de distance d(v)
|
|
|
# minimale
|
|
|
# ⋆ pour tout voisin w de v qui n’est pas dans T :
|
|
|
# - si d(v) plus le poids p de l’arˆete (v,w) est inf ́erieur `a
|
|
|
# d(w), on fixe d(w)=d(v)+p
|
|
|
# - ajouter w `a L
|
|
|
# ⋆ enlever v de L, ajouter v `a T
|
|
|
# Impl ́ementez l’algorithme en suivant les ́etapes suivantes :
|
|
|
# 1. ́Ecrire une fonction mise_a_jour_voisin(G,n,v) qui met `a jour la distance du som-
|
|
|
# met v `a la source (v est suppos ́e voisin de n dans le graphe G) `a partir de celle du
|
|
|
# sommet n (en supposant que la distance du sommet n `a la source est un nombre)
|
|
|
|
|
|
def mise_a_jour_voisin(G,n,v):
|
|
|
G.nodes[v]["distance"]=G.edges[(n,v)]["weight"]
|
|
|
|
|
|
print(mise_a_jour_voisin(G,"A","B"))
|
|
|
|
|
|
# 2.
|
|
|
# Ecrire une fonction choix_prochain_sommet(G,L), qui renvoie le sommet de la fronti`ere
|
|
|
# L qui sera choisi pour la prochaine it ́eration de l’algorithme de Dijkstra.
|
|
|
|
|
|
def choix_prochain_sommet(G,L):
|
|
|
return min(L,key=lambda x:G.nodes[x]["distance"])
|
|
|
|
|
|
print(choix_prochain_sommet(G,["A","B","C","D","E","F","G","H","I","J"]))
|
|
|
|
|
|
# 3.
|
|
|
# Ecrire une fonction Dijkstra(G,s) qui d ́etermine les distances entre le sommet s et
|
|
|
# tous les autres sommets dans le graphe valu ́e G.
|
|
|
|
|
|
def Dijkstra(G,s):
|
|
|
L=[s]
|
|
|
G.nodes[s]["distance"]=0
|
|
|
while L!=[]:
|
|
|
v=choix_prochain_sommet(G,L)
|
|
|
for w in G.neighbors(v):
|
|
|
if w not in L:
|
|
|
if G.nodes[v]["distance"]+G.edges[(v,w)]["weight"]<G.nodes[w]["distance"]:
|
|
|
G.nodes[w]["distance"]=G.nodes[v]["distance"]+G.edges[(v,w)]["weight"]
|
|
|
L.append(w)
|
|
|
L.remove(v)
|
|
|
|
|
|
print(Dijkstra(G,"A"))
|
|
|
|
|
|
# 4.Coder et tester l’algorithme de Floyd-Warshall, rappel ́e ci-dessous :
|
|
|
# Algorithme de Floyd-Warshall pour le graphe G
|
|
|
# • Les sommets sont ordonn ́es : s1 ... sn avec n le nombre de sommets
|
|
|
# • On initialise une matrice D de taille n×n, o`u D(i, j) devra contenir la
|
|
|
# distance entre le sommet si et le sommet sj . Pour toute arˆete entre si et
|
|
|
# sj de poids pij , on fixe D(i, j) = pij , et pour tout i on fixe D(i, i) = 0.
|
|
|
# Dans les autres cas, on fixe D(i, j) = ∞.
|
|
|
# • Pour k allant de 1 `a n :
|
|
|
# • Pour i allant de 1 `a n :
|
|
|
# • Pour j allant de 1 `a n :
|
|
|
# D(i, j) = min{D(i, j), D(i, k) + D(k, j)}
|
|
|
# • Renvoyer D
|
|
|
# Pourquoi n’est-t-il pas n ́ecessaire de copier la matrice D `a chaque ́etape ? V ́erifier que
|
|
|
# l’algorithme ne va pas ́ecraser des donn ́ees importantes en cours de route
|
|
|
|
|
|
def Floyd_Warshall(G):
|
|
|
n=len(G.nodes())
|
|
|
D=[[float("inf") for i in range(n)] for j in range(n)]
|
|
|
for i in range(n):
|
|
|
D[i][i]=0
|
|
|
for j in range(n):
|
|
|
if (i,j) in G.edges():
|
|
|
D[i][j]=G.edges[(i,j)]["weight"]
|
|
|
for k in range(n):
|
|
|
for i in range(n):
|
|
|
for j in range(n):
|
|
|
D[i][j]=min(D[i][j],D[i][k]+D[k][j])
|
|
|
return D
|
|
|
|
|
|
print(Floyd_Warshall(G))
|
