Chapitre : Les Graphes

Définitions :
Un graphe est un ensemble de sommets (ou nœuds) et d’arcs reliant ces sommets. Un graphe est
représenté formellement par G = (S, A) ou
S = {s1, s2,…, sn} est un ensemble de sommets (nœuds) et
A = {a1, a2, …., am} un ensemble d'arêtes (arcs).
Un sommet est une représentation abstraite d'un objet.
Une arrête représente une relation binaire entre deux objets
Les graphes peuvent être utilisés pour modéliser :
Les réseaux sociaux : Liste des amis sur facebook
Les réseaux : routiers, ferroviaire, téléphoniques, informatique, … etc.
Le web : chaque page est un sommet du graphe, chaque lien hypertexte est une arête entre deux
sommets
Graphe non orienté : Un graphe non orienté G est un couple (S,A) de deux ensembles finis, où les
éléments de S sont les sommets de G et les éléments de A sont des couples d’éléments de S appelés
arêtes. Une arête dont l’origine et la fin sont confondus est appelée boucle.
Exemple

S = {1; 2; 3; 4}
A = {{1; 2}; {1; 3}; {1; 4}; {2; 4}; {3; 4}}
Graphe orienté : Un graphe orienté G est un graphe où les éléments de A sont des couples d’éléments
de S appelés arcs.
Exemple
S = {1; 2; 3; 4}
A = {{1; 2}; {1; 3}; {1; 4}; {2; 4}; {3; 4}}

Graphe valué : C’est un triplet (S,A,f) où G=(S,A) est un graphe et f est une fonction à arguments dans
A qui à tout arc a (arête) de A associe une valeur f(a)( distance entre deux villes, temps du trajet,...).
Chemin : Un chemin reliant deux sommets i et j est une suite d’arcs commençant en i et se terminant
en j, La longueur d’un chemin est le nombre d’arcs qui le
constituent.

1
Représentation physique d’un graphe :
Représentation par dictionnaire : Représentation matricielle :Matrice d’adjacence
D = dict()
B
D[A] = [B,E,F] C a
a b c d b
D[B]=[A,C,E]
A
E a 0 1 1 1
D[C] = [B,D,E]
D c
b 1 0 0 1 d
D[D] = [C,G] F
G
D[E] = [A,B,C,F,G] c 1 0 0 0
D[F] = [A,E,G] d 1 1 0 0
D[G] = [D,E,F]

Représentation par liste d’adjacence :

S=[a,b,c,d]
L=[[b,c,d],[a,d],[a],[a,b]]
Parcours d’un graphe : Parcours en profondeur : (Depth First Search)
Parcourir un graphe en profondeur à partir d’un sommet donné, revient à suivre un chemin le plus loin
possible, en marquant tous les sommets visités, jusqu’à trouver une impasse : sommet où tous les
sommets adjacents sont déjà visités (marqués), puis revenir en arrière sur le chemin que l’on vient de
parcourir, jusqu’à trouver une nouvelle branche non encore visitée et ainsi de suite.

L'algorithme
1. Choisissez n'importe quel nœud. S'il n'est pas visité, marquez-le comme visité et répétez-le sur
tous ses nœuds adjacents.
2. Répétez jusqu'à ce que tous les nœuds soient visités.

Algorithme : on utilise une pile

DFS (graphe G, sommet s)
DEBUT
Marquer(s)
POUR CHAQUE élément s_fils de Voisins(s)FAIRE
SI NonMarqué(s_fils) ALORS
DFS(G,s_fils)
FIN-SI
FIN-POUR
FIN.

2
Programmation python du parcours
Représentation de la structure de graphe.
On utilisera un dictionnaire python pour la structure de graphe.
Le graphe G ci-dessous

g = dict() graph = {
g['A'] = ['B','C'] 'A' : ['B','C'],
g['B']= ['D', 'E'] 'B' : ['D', 'E'],
g['C'] = ['F'] 'C' : ['F'],
g['D'] = [] 'D' : [],
g['E']=['F'] 'E' : ['F'],
g['F']= [] 'F' : []
}

def DFS (G,s,D):

print(s,end=', ')
for s_fils in G[s]:
if not s_fils in D:
D.append(s_fils)
DFS(G,s_fils,D)

Appel : DFS(G,’a’,[‘a’])

Parcours en largeur : (Breadth First Search)

Dans un parcours en largeur : on procède par niveau en particulier, BFS suit les étapes suivantes :
L'algorithme
1. Vérifiez le nœud de départ et ajoutez ses voisins à la file d'attente.
2. Marquez le nœud de départ comme exploré(découvert)
3. Récupérez le premier nœud de la file d'attente / supprimez-le de la file d'attente
4. Vérifiez si le nœud a déjà été visité.
5. Sinon, passez par les voisins du nœud.
6. Ajoutez les nœuds voisins à la file d'attente.
7. Marquez le nœud comme exploré.
8. Suivez les étapes 3 à 7 jusqu'à ce que la file d'attente soit vide.
Programmation python du parcours def BFS(G,sommet) :
Découverts, File=[sommet],[sommet]
while File :
s=File.pop(0)
for fils in G[s] :
if not fils in Découverts:
Découverts.append(fils)
File.append(fils)
return Découverts
3
Partie 2 : Utilisation de la bibliothèque networkx
Introduction à networkx
Import de la bibliothèque :
import networkx as nx
import numpy as np
import matplotlib.pyplot as plt
g = nx.Graph() # DiGraph() pour un graphe orienté
g.add_nodes_from(range(5))
g.add_edges_from([(0,1),(3,4),(4,2),(1,3),(4,0),(1,2)])
Les méthodes suivantes permettent d’accéder aux attributs du graphe et fournissent les
primitives essentielles :
g.degree() : degrés des sommets du graphe g
g.number_of_nodes() : nombre de sommets du graphe g
g.number_of_edges() : nombre d’arcs du graphe g
list(g.neighbors(i)) : liste des voisins du sommet i
Matrice d’adjacence :
A= nx.adjacency_matrix(g)
Print(A.todense()
Affichage du graphe :
nx.draw(g, pos=nx.circular_layout(g), node_color='r', edge_color='b',with_labels=True)
Ou
import matplotlib.pyplot as plt
f, ax = plt.subplots(figsize=(6,3))
nx.draw(g, ax = ax)

On dispose aussi des indicateurs et outils suivants (liste non exhaustive) :

density(g) : densité du graphe g
diameter(g) : diamètre du graphe g
nx.shortest_path(g) : plus courts chemins entre tous les couples de sommets de g