Théorie Des Graphes Chap 2 Et Chap 3

RESPONSABLE: SANAE MOUSSAOUI
En utilisant un graphe comme modèle, beaucoup de problèmes sur les graphes

nécessitent un examen exhaustif des sommets le long des arcs/arêtes du
graphe. Des algorithmes de parcours de graphes servent de base à un très
nombre d’algorithmes.
Alors, parcourir un graphe consiste à visiter ses sommets, en suivant des
arêtes ( des arcs) qui les relient.
Utilité:
Un parcours sert dans la résolution d'un certain nombre de problèmes parmi
lesquels :
- Connexité et forte connexité;
- Existence d'un circuit ou d'un cycle (ce qu’on appelle tri topologique);
- Calcul des plus courts chemins (notamment l’algorithme de Dijkstra);
- Calcul d'un arbre couvrant (notamment l’algorithme de Prim);
Exploration d’un graphe
Définition:
On appelle exploration/parcours un procédé déterministe ( un algorithme) consistant à
explorer les sommets d'un graphe de proche en proche à partir d'un sommet initial.
 La notion d’exploration/parcours peut être utiliser dans les graphes orientés et non-
orientés.
Définition:
Le sommet de départ fixé à l’avance, dont on souhaite visités tous les descendants est
appelé racine d’exploration.
Définition:
Un parcours de racine r est une suite L de sommets tel que :
- r est le premier sommet de L.
- Tout les sommets sauf la racine est adjacent à un sommet placé avant lui dans la liste.
Il existe deux types d’explorations:

 Parcours en largeur;
 Parcours en profondeur.
Définition:
Soient G = (S, A) un graphe non-pondéré, x et y deux sommets de G. On pose d(x, y) =
longueur d’un plus court chemin (chaine) entre x et y (en nombre d’arcs ou arêtes). d(x, y)
s’appelle distance entre x et y.
 S’il n’existe pas de chaine ou chemin entre x et y on pose d(x, y) = +∞
Exemple:
2
1 4 d(1,2)=1, d(2,3)=2, d(1,4)=2
3
Définition:
On appelle partition en couches associée à un sommet source r appelé racine, la suite
d’ensembles définis exactement comme suit :
- C0 = {r}
- C1 = {x ∈ S / d(x,r) = 1}
⋮
- Cn = {x ∈ S / d(x,r) = n}
 Cas orienté: On définit les couches de la même manière, dont les descendants d’un
sommet représentent ses successeurs.
Peut-on savoir si un
graphe représenté par
sa liste d’adjacence est
biparti? est connexe?
Parcours en Largeur
Parcours en Largeur ?
Définition:
Le parcours en largeur (ou BFS pour Breadth First Search) débute à partir d'un nœud
source. Puis il liste tous les voisins de la source, pour ensuite les explorer un par un
dans l’ordre. Ce mode de fonctionnement utilise donc une file dans laquelle il prend le
premier sommet et place en dernier ses voisins non encore explorés. Les nœuds déjà
visités sont marqués afin d'éviter qu'un même nœud soit exploré plusieurs fois.
 Ce problème peut être vu comme un plus court chemin, mais notre graphe implicite
est non pondéré contrairement aux autres algorithmes "classiques" de plus court
chemin où le graphe est pondéré (positivement ou négativement). Cela revient donc à
trouver un chemin entre l'entrée et la sortie comportant un minimum de nœuds
possible (vu que les arcs ont chacun une distance de 1 unité).
Parcours en Largeur
Utilité:
Le BFS sert à :
 trouver le plus court chemin dans un graphe non pondéré;
 Déterminer si le graphe est connexe;
 Déterminer si le graphe est biparti, etc.
Parcours en Largeur
Principe:
Le BFS, visite les nœuds du graphe par ordre de profondeur. C'est-à-dire que
l'algorithme va d'abord visiter les nœuds à une profondeur de 1 par rapport au
nœud de départ, puis à une profondeur de 2, de 3, etc. On parcourt le graphe
"couche par couche" .
Algorithme:
1- mettre le nœud source dans la file ;
2- retirer le nœud du début de la file pour le traiter ;
3- mettre tous ses voisins non explorés dans la file (à la fin) ;
4- si la file n'est pas vide reprendre à l'étape 2.
Parcours en Largeur
Définition:
Un sommet est dit marqué s’il a été placé dans une couche Ci .
2 3
1 1 Ou bien 1 1
Définition:
Un sommet est dit exploré lorsqu’on aura marqué tous les voisins.
2 2 2
1 1 1
3 3 3
Ou bien
0 0 3
2 2 2
0 2 2
1 1 1
0 0 3
3 3 3
Parcours en Largeur
Propriété:
Lors d’un parcours en largeur on applique la règle: premier marqué premier exploré.
Pour construire les couches, on explore les sommets en respectant l’ordre dans lequel
ils ont été marqués. La gestion des sommets est réalisable au moyen d’une structure de
données appelée file.
Définition:
Une file (queue) est une structure de données basée sur FIFO. Ce qui veut dire que les
premiers éléments ajoutés à la file sont les premiers à être récupérés.
Exemple:
Enfiler Obj3 Obj2 Obj1 Défiler

Parcours en Largeur
Implémentation:
- On utilise une file de taille n + 1 où n = |S| est le nombre de sommets du graphe.
- On associe à chaque sommet un numéro.
- la racine aura le numéro 1.
- les sommets marqués à partir d’une couche Ci auront le numéro i + 1.
Algorithme BFS : Breadth First Search

Procédure Largeur (G graphe, r sommet)
Pour i = 1 à n faire
Marquer[i] = 0
fin pour
tête ← 1
queue ← 1
file [tête] ← r
tant que tête ≤ queue faire
x ←- file[tête]
pour y ≠ r parcourant la liste des successeurs de x faire
si marquer[y]=0, alors
marquer[y]=marquer[x] + 1
queue ← queue + 1
file[queue] ←- y
fin si
fin pour
tête ← tête +1
fin tant que
fin
Exemple:
Considérons le graphe non-orienté non pondéré suivant:
10
2 3
8
4 5
7 9
6
En appliquant l’algorithme de parcours en largeur à partir de la racine 1, on obtient:

0
1
0
0 0 10
2 3
0
0
0 8
4 5
0 0 0
7 9
6
0
1
0
0 0 10
2 3
0
0
0 8
4 5
0 0 0
7 9
6
0
1
0
1 0 10
2 3
0
0
0 8
4 5
0 0 0
7 9
6
0
1
0
1 0 10
2 3
0
0
0 8
4 5
0 0 0
7 9
6
0
1
0
1 1 10
2 3
0
0
0 8
4 5
0 0 0
7 9
6
0
1
0
1 1 10
2 3
0
0
0 8
4 5
0 0 0
7 9
6
0
1
0
2 1 10
2 3
0
0
0 8
4 5
0 0 0
7 9
6
0
1
0
1 1 10
2 3
0
0
0 8
4 5
0 0 0
7 9
6
0
1
0
1 1 10
2 3
0
0
2 8
4 5
0 0 0
7 9
6
0
1
0
1 1 10
2 3
0
0
2 8
4 5
0 0 0
7 9
6
0
1
0
1 1 10
2 3
0
2
2 8
4 5
0 0 0
7 9
6
0
1
0
1 1 10
2 3
0
2
2 8
4 5
0 0 0
7 9
6
0
1
0
1 1 10
2 3
0
2
2 8
4 5
0 0 0
7 9
6
0
1
2
1 1 10
2 3
0
2
2 8
4 5
0 0 0
7 9
6
0
1
2
1 1 10
2 3
0
2
2 8
4 5
0 0 0
7 9
6
0
1
2
1 1 10
2 3
0
2
2 8
4 5
0 0 0
7 9
6
0
1
2
1 1 10
2 3
0
2
2 8
4 5
0 0 0
7 9
6
0
1
2
1 1 10
2 3
0
2
2 8
4 5
3 0 0
7 9
6
0
1
2
1 1 10
2 3
0
2
2 8
4 5
3 0 0
7 9
6
0
1
2
1 1 10
2 3
0
2
2 8
4 5
3 0 0
7 9
6
0
1
2
1 1 10
2 3
0
2
2 8
4 5
3 0 0
7 9
6
0
1
2
1 1 10
2 3
0
2
2 8
4 5
3 0 0
7 9
6
0
1
2
1 1 10
2 3
0
2
2 8
4 5
3 0 0
7 9
6
0
1
2
1 1 10
2 3
3
2
2 8
4 5
3 0 0
7 9
6
0
1
2
1 1 10
2 3
3
2
2 8
4 5
3 0 0
7 9
6
0
1
2
1 1 10
2 3
3
2
2 8
4 5
3 0 0
7 9
6
0
1
2
1 1 10
2 3
3
2
2 8
4 5
3 0 0
7 9
6
0
1
2
1 1 10
2 3
3
2
2 8
4 5
3 4 0
7 9
6
0
1
2
1 1 10
2 3
3
2
2 8
4 5
3 4 0
7 9
6
0
1
2
1 1 10
2 3
3
2
2 8
4 5
3 4 0
7 9
6
0
1
2
1 1 10
2 3
3
2
2 8
4 5
3 4 0
7 9
6
0
1
2
1 1 10
2 3
3
2
2 8
4 5
3 4 4
7 9
6
0
1
2
1 1 10
2 3
3
2
2 8
4 5
3 4 4
7 9
6
0
1
2
1 1 10
2 3
3
2
2 8
4 5
3 4 4
7 9
6
Conclusion 0
1 𝑑 𝑥, 1 = 0
1 1
2 3 𝑑 𝑥, 1 = 1
2
2 2
4 5 10 𝑑 𝑥, 1 = 2
3
3
8 𝑑 𝑥, 1 = 3
6
Plus courte chaîne

4 4
7 9 𝑑 𝑥, 1 = 4
0
1
1 1
2 3
2
2 2
4 5 10
3
3
8
6
Graphe connexe
4 4
7 9
0
1
1 1
2 3
2
2 2
4 5 10
3
3
8
6
Graphe connexe
4 4
7 9
Tester si un graphe est biparti en utilisant le parcours en largeur
10
2 3
8
4 5
7 9
6
0
1
1 1
2 3
2
2 2
1
4 5 0
3 3
8
6
4 4
7 9
1- Faire un parcours en largeur du graphe

0
1
1 1
2 3
2
2 2
1
4 5 0
3 3
8
6
4 4
7 9
2- Colorier les niveau pairs en rouge et les niveaux

impairs en vert
0
1
1 1
2 3
2
2 2
1
4 5 0
3 3
8
6
4 4
7 9
3- Tester si aucun arc/arête entre les sommets d’un même

niveau.
0
1
1 1
2 3
2
2 2
1
4 5 0
3 3
8
6
4 4
7 9

niveau.
0
1
1 1
2 3
2
2 2
1
4 5 0
3 3
8
6
4 4
7 9

niveau.
0
1
1 1
2 3
2
2 2
1
4 5 0
3 3
8
6
4 4
7 9

niveau.
1
2
4
3 5
7
6
8 1
0
Alors, le graphe est biparti.

Si nous modifions l'ordre
dans lequel les sommets
entrent dans la liste
d’adjacence, y aura-il une
différence ?
0
1
1 1
2 3
2
2 2
1
4 5 0
3 3
8
6
4 4
7 9
Liste d’adjacence décroissante

0
1
1 1
2 3
2
2 2
1
4 5
0
3
3
8
6
4 4
7 9 Liste d’adjacence décroissante
0
Liste d’adjacence croissante 1
1 1
2 3
2
2 2
1
4 5
0
3 3
8
6
4 4
7 9
Problématique:
Vous vous trouvez dans un labyrinthe contenant de nombreux chemins
possibles, et vous cherchez la sortie alors que vous ne connaissez
aucunes indications sur ce labyrinthe.
Dans notre labyrinthe, nous essayons d'abord de marcher tout droit jusqu'à se
retrouver coincé
À ce stade, nous tournons à droite jusqu'à atteindre une bifurcation.

Encore une fois, nous essayons d'aller tout droit et de tourner à gauche
jusqu'à nous retrouver bloqués.
Encore une fois, nous essayons d'aller tout droit et de tourner à gauche
jusqu'à nous retrouver bloqués.
Ensuite, nous revenons à la dernière intersection, et nous continuons

jusqu'à être bloqué ou tomber sur la sortie.
C’est terminé!
Situation 1
Supposons que nous rencontrions cette situation, comment

pouvons-nous en sortir ?
Situation 2
1- Tout d'abord, on peut représenter notre

labyrinthe comme un graphe dit implicite, qui sera
non pondéré (chaque arc aura alors une distance
de 1 unité).
2- Chaque intersection sera représentée par un

nœud du graphe, et chaque chemin par un arc.
L'entrée et la sortie du labyrinthe sont juste de
simples nœuds distincts du graphe, et le fait de
trouver la sortie du labyrinthe, revient à trouver un
chemin reliant le nœud d'entrée au nœud de
sortie.
Vu qu'on ne connait rien sur ces labyrinthes, il est impossible de
deviner le chemin nous permettant d'arriver à la sortie puisque ça
pourrait être n'importe lequel du graphe. On peut donc tout
simplement essayer chacun des chemins jusqu'à trouver le bon. Ce
parcours est alors qualifié de :
Parcours en Profondeur
Définition:
Le parcours d’un graphe en profondeur (ou plus communément DFS pour Depth
First Search) se réalise en partant d’un sommet arbitraire v à visiter, et en
parcourant d’abord un de ses voisins u et tous ses “descendants” (c’est-à-dire
tous les sommets accessibles à partir de u) avant de traiter le voisin suivant de
v. Une fois ces descendants explorés, on applique le même traitement au
prochain voisin de v non encore visité, et ainsi de suite jusqu’à ce que tous les
sommets aient été couverts. On manipulera tout au long de notre parcours une
liste résultat, enregistrant les identifiants des sommets au fur et à mesure qu’on
les découvre.
Implémentation
On peut implémenter un DFS de deux manières différentes, même si on
a plutôt tendance à le coder de manière récursive car le code est plus
court et plus intuitif.
 Implémentation de l’algorithme DFS récursivement
Principe:
Le parcours en profondeur permet de parcourir un graphe en utilisant le principe
de la récursivité. Ce parcours visite les nœuds du graphe les plus "profonds" en
premier (c'est-à-dire les plus éloignés du nœud de départ), avant de "remonter"
progressivement dans le graphe.
Algorithme:
On considère un graphe dont tous les sommets sont initialement non découverte
(couleur est blanche). Le parcours en profondeur consiste à:
- Choisir un sommet de départ s et le marquer comme découvert.
- Suivre un chemin issu de s aussi loin que possible en marquant les sommets au fur et à
mesure qu’on les découvrent.
- A la fin du chemin (marqué en noir) revenir au dernier choix du sommet et prendre une
autre direction.
Dans les sommets, on utilise les champs : couleur, père, découvert, fin.
Algorithme DFS : Depth First Search ( récursive)

Procédure DFS(G: graphe)
variable U :sommet
Pour tout nœud U de G faire
U.couleur ← blanc
U.père ← null
fin pour
temps ← 0
pour tout nœud U de G faire
si U.couleur=blanc alors U.découvert ← temps
temps ← temps+1
U.couleur ← gris
(dans la suite on doit visiter tous les successeurs de U découvert)
DFS-Visiter(G,U)
fin si
fin pour
fin
Procédure DFS-Visiter(G: graphe,U: sommet)

Variables V : sommet
Pour tout sommet V successeur de U faire
si V.couleur=blanc alors V.decouvert ← temps
temps ← temps+1
V.couleur ← gris
V.père ← U
DFS-Visite(G,V)
fin si
fin pour
U.fin ← temps
V.couleur ← noir
temps ← temps+1
fin
Exemple 1:
Considérons le graphe orienté non pondéré suivant:
10
2 3
8
4 5
7 9
6
En appliquant l’algorithme de parcours en Profondeur, on obtient:

./.
./.
./. ./. 10
2 3
./. ./.
./. 8
4 5
./. ./.
7 9
6
./.
0/.
./.
./. ./. 10
2 3
./. ./.
./. 8
4 5
./. ./.
7 9
6
./.
0/.
./.
1/. ./. 10
2 3
./. ./.
./. 8
4 5
./. ./.
7 9
6
./.
0/.
./.
1
1/. ./. 10
2 3
./. ./.
./. 8
4 5
./. ./.
7 9
6
./.
0/.
./.
1
1/. ./. 10
2 3
./. ./.
2/. 8
4 5
./. ./.
7 9
6
./.
0/.
./.
1
1/. ./. 10
2 3
./. ./.
2
2/. 8
4 5
./. ./.
7 9
6
./.
0/.
./.
1
1/. ./. 10
2 3
./. ./.
2
2/. 8
4 5
./. ./.
7 9
6
3/.
0/.
./.
1
1/. ./. 10
2 3
./. ./.
2
2/. 8
4 5
./. ./.
7 9
6
4
3/.
0/.
./.
1
1/. ./. 10
2 3
./. ./.
2
2/. 8
4 5
./. ./.
7 9
6
4
3/.
0/.
./.
1
1/. ./. 10
2 3
./. ./.
2
2/. 8
4 5
./. ./.
7 9
6
4
3/4
0/.
./.
1
1/. ./. 10
2 3
./. ./.
2
2/. 8
4 5
./. ./.
7 9
6
4
3/4
0/.
./.
1
1/. ./. 10
2 3
./. ./.
2
2/5 8
4 5
./. ./.
7 9
6
4
3/4
0/.
./.
1
1/. ./. 10
2 3
./. ./.
2
2/5 8
4 5
./. ./.
7 9
6
4
3/4
0/.
./.
1
1/. ./. 10
2 3
6/. ./.
2
2/5 8
4 5
./. ./.
7 9
6
4
3/4
0/.
./.
1
1/. ./. 10
2 3
2 ./.
6/.
2
2/5 8
4 5
./. ./.
7 9
6
4
3/4
0/.
./.
1
1/. 7/. 10
2 3
2 ./.
6/.
2
2/5 8
4 5
./. ./.
7 9
6
4
3/4
0/.
./.
1 5
1/. 7/. 10
2 3
2 ./.
6/.
2
2/5 8
4 5
./. ./.
7 9
6
4
3/4
0/.
./.
1 5
1/. 7/8 10
2 3
2 ./.
6/.
2
2/5 8
4 5
./. ./.
7 9
6
4
3/4
0/.
./.
1 5
1/. 7/8 10
2 3
2 ./.
6/.
2
2/5 8
4 5
./. ./.
7 9
6
4
3/4
0/.
./.
1 5
1/. 7/8 10
2 3
2 ./.
6/.
2
2/5 8
4 5
./. ./.
7 9
6
4
3/4
0/.
./.
1 5
1/. 7/8 10
2 3
2 ./.
6/9
2
2/5 8
4 5
./. ./.
7 9
6
4
3/4
0/.
./.
1 5
1/. 7/8 10
2 3
2 ./.
6/9
2
2/5 8
4 5
./. ./.
7 9
6
4
3/4
0/.
./.
1 5
1/10 7/8 10
2 3
2 ./.
6/9
2
2/5 8
4 5
./. ./.
7 9
6
4
3/4
0/.
./.
1 5
1/10 7/8 10
2 3
2 ./.
6/9
2
2/5 8
4 5
./. ./.
7 9
6
4
3/4
0/11
./.
1 5
1/10 7/8 10
2 3
2 ./.
6/9
2
2/5 8
4 5
./. ./.
7 9
6
4
3/4
0/11
./.
1 5
1/10 7/8 10
2 3
2 ./.
6/9
2
2/5 8
4 5
12/.
./.
7 9
6
4
3/4
0/11
./.
1 5
1/10 7/8 10
2 3
2 13/.
6/9
2
2/5 8
4 5
12/.
./.
7 9
6
4
3/4
0/11
./.
1 5
1/10 7/8 10
2 3
2 7
13/.
6/9
2
2/5 8
4 5
12/.
./.
7 9
6
4
3/4
0/11
./.
1 5
1/10 7/8 10
2 3
2 7
13/.
6/9
2
2/5 8
4 5
12/.
14/.
7 9
6
4
3/4
0/11
./.
1 5
1/10 7/8 10
2 3
2 7
13/.
6/9
2
2/5 8
4 5
12/. 8
14/.
7 9
6
4
3/4
0/11
./.
1 5
1/10 7/8 10
2 3
2 7
13/.
6/9
2
2/5 8
4 5
12/. 8
14/.
7 9
6
4
3/4
0/11
./.
1 5
1/10 7/8 10
2 3
2 7
13/.
6/9
2
2/5 8
4 5
12/. 8
14/15
7 9
6
4
3/4
0/11
./.
1 5
1/10 7/8 10
2 3
2 7
13/.
6/9
2
2/5 8
4 5
12/. 8
14/15
7 9
6
4
3/4
0/11
16/.
1 5
1/10 7/8 10
2 3
2 7
13/.
6/9
2
2/5 8
4 5
12/. 8
14/15
7 9
6
4
3/4
0/11
1
8
16/.
1 5
1/10 7/8 10
2 3
2 7
13/.
6/9
2
2/5 8
4 5
12/. 8
14/15
7 9
6
4
3/4
0/11
1
8
16/.
1 5
1/10 7/8 10
2 3
2 7
13/.
6/9
2
2/5 8
4 5
12/. 8
14/15
7 9
6
4
3/4
0/11
1
8
16/17
1 5
1/10 7/8 10
2 3
2 7
13/.
6/9
2
2/5 8
4 5
12/. 8
14/15
7 9
6
4
3/4
0/11
1
8
16/17
1 5
1/10 7/8 10
2 3
2 7
13/.
6/9
2
2/5 8
4 5
12/. 8
14/15
7 9
6
4
3/4
0/11
1
8
16/17
1 5
1/10 7/8 10
2 3
2 7
13/18
6/9
2
2/5 8
4 5
12/. 8
14/15
7 9
6
4
3/4
0/11
1
8
16/17
1 5
1/10 7/8 10
2 3
2 7
13/18
6/9
2
2/5 8
4 5
12/. 8
14/15
7 9
6
4
3/4
0/11
1
8
16/17
1 5
1/10 7/8 10
2 3
2 7
13/18
6/9
2
2/5 8
4 5
12/. 8
14/15
7 9
6
4
3/4
0/11
1
8
16/17
1 5
1/10 7/8 10
2 3
2 7
13/18
6/9
2
2/5 8
4 5
12/19 8
14/15
7 9
6
4
3/4
1
10
2 3
8
4 5
7 9
6
Forêt
1 7
2
8
4 5
9 10
6 3
Arborescence de racine 1 Arborescence de racine 7

Représentation en machine d’un 1-graphe

A tout graphe orienté G = (S, A) avec |S| = n et |A| = m.
On peut associer deux tableaux PS et LS:
- PS tableau de pointeurs à n + 1 éléments, où PS[i] point sur la case contenant le
premier successeur du sommet i dans LS (liste des successeurs).
- LS tableau à m éléments où les successeurs d’un sommet i se trouvent
entre la case numéro PS[i] et la case PS[i + 1] du tableau LS.
On pose pour tout 2 ≤ i ≤ n, PS[i] = PS[i - 1]+ nombre des successeur de i – 1.
On pose PS[n+ 1] =m+1
Si un sommet n’a pas de successeur on aura PS[i + 1] = PS[i].
Exemple:
10
2 3
8
4 5
7 9
6
PS 1 3 5 5 6 9 10 12 14 15 17
LS 2 3 4 5 6 1 3 6 2 6 8 9 10 7 3 9
 Implémentation de l’algorithme DFS en utilisant les piles
Principe
la gestion des sommets est réalisable à l’aide d’une structure de données
appelée pile. Une pile est une structure de données basée sur le principe
dernier entré, premier sortie (LIFO).
2 1 Dépiler
Empiler
Obj4 Obj3 Obj3
Obj3 Obj4
Obj2 Obj2
Obj1 Obj1
 Implémentation de l’algorithme DFS en utilisant les piles
Algorithme DFS : Depth First Search ( en utilisant la pile)

Procédure DFS (G : graphe, r : sommet)
pour i = 1 à n faire
marque[i] ← faux
fin pour
h ← 1 (hauteur de la pile)
pile[h] ← r
tant que h > 0 faire
x ← pile[h]
si PS[x] ≠ 0 alors y ← LS[PS[x]]
si marque[y]=faux alors marque[y] ← vrai
h←h+1
pile[h] ← y (empiler y)
fin si
mettre à jour PS[x] (PS[x] pointe maintenant vers le premier successeur non visité de x)
sinon (si PS[x] = 0, cas où il n’a pas de successeur non visité de x)
dépiler(pile[h])
h←h-1
fin si
fin tant que
fin
Utilité:
Un parcours en profondeur permet de:
- Trouver tous les sommets atteignables depuis un sommet initial u, c’est-à-dire
l’ensemble des sommets v pour lesquels il existe une marche menant de u à v;
- Identifie les sous arbres et leurs racines;
- Déterminer les composantes fortement connexes;
- Existence d'un circuit ou d'un cycle,etc.
Exemple 2:
10
2 3
8
4 5
7 9
6
Appliquer l’algorithme de parcours en Profondeur en utilisant les piles.

Tableau de marquage des sommets
1 2 3 4 5 6 7 8 9 10
Itération 0 Faux Faux Faux Faux Faux Faux Faux Faux Faux Faux
1 2 3 4 5 6 7 8 9 10
Itération 1 Vrai Faux Faux Faux Faux Faux Faux Faux Faux Faux
1 2 3 4 5 6 7 8 9 10
Itération 2 Vrai Vrai Faux Faux Faux Faux Faux Faux Faux Faux
1 2 3 4 5 6 7 8 9 10
Itération 3 Vrai Vrai Faux Vrai Faux Faux Faux Faux Faux Faux
1 2 3 4 5 6 7 8 9 10
Itération 4 Vrai Vrai Faux Vrai Faux Vrai Faux Faux Faux Faux
1 2 3 4 5 6 7 8 9 10
Itération 5 Vrai Vrai Faux Vrai Vrai Vrai Faux Faux Faux Faux
1 2 3 4 5 6 7 8 9 10
Itération 5 Vrai Vrai Faux Vrai Vrai Vrai Faux Faux Faux Faux
Itération 6 Vrai Vrai Vrai Vrai Vrai Vrai Faux Faux Faux Faux
Conclusion:
- Il n’existe aucun chemin à partir du sommet 1 vers les sommets 3, 7, 8, 9 et 10.
- Elle n’existe aucune arborescence à partir de 1.
- Il existe un sous-graphe sous forme d’une arborescence à partir de 1 ( formée
par les sommets qui sont marqués).
4 5
6 3
Sous arbre enraciné en 1

Algorithme des composantes fortement connexes
Entrée: un graphe orienté G = (S, A)
Sortie: Les composantes fortement connexes de G
H←S
C←∅
Créer une pile P
Tant que H n’est pas vide faire
Choisir un sommet s∈ H
empiler({s},P), P=< X0, X1,…, Xk> où ∅ ≠Xi ⊂ S et Xk est le sommet de la pile
Tant que P n’est pas vide faire
s’il existe (s,s ′) non marqué avec s ∈ Xk et s ′ ∈ H alors
marquer (s,s ′)
si s ′ ∉ P alors
Empiler({s’},P)
sinon
Remplacer Xi par Xi∪Xi+1∪…∪Xk où s’ ∈ Xi
dépiler k − i fois P
Fin si
sinon
C ← C ∪ {Xk}
H ← H \ Xk
dépiler une fois P
Fin si
s ← s’
Fin tant que
Fin tant que
Retourner C
Exemple 3:
d f
e
c
j h
a
b i
g
Est-il fortement connexe?

d f
e
c
j h
a
b i
g
Problématique:
Supposons qu’on souhaite mettre en place un réseau informatique entre les villes a,
b, c, d, e et f. Une estimation des coûts d’installation entre certaines de ces villes à
donnée les valeurs suivantes.
b 4 e
1
3 6
a 3 2
d
7 10
3
c 5
f
On souhaite choisir les liaisons à effectuer afin que toutes les villes soient reliées au
réseau tout en minimisant le coût total.
Arbres couvrants
Définition:
Soit G un graphe à n sommets, alors on a les équivalences suivantes :
1- G est un arbre.
2- G est sans cycle et connexe.
3- G est sans cycle et comporte n − 1 arêtes.
4- G est connexe et comporte n − 1 arêtes.
5- Chaque pair de sommets x, y distincts est relié par une seule chaine simple
et le graphe est sans boucles.
Définition:
Soit G un graphe orienté ou non. Un arbre couvrant est un sous-graphe de G
qui est un arbre.
Arbres couvrants de poids
minimal
Définition:
Un graphe (orienté ou non) G = (S, A) est dit valué ( ou bien pondéré) s’il est muni
d’une application v: A → ℝ, (x, y) ↦ v(x, y) appelée valuation.
On note G = (S, A, v) un graphe muni d’une valuation v.
Utilité:
Les graphes valués servent à résoudre de nombreux problèmes d’optimisation La
valuation peut représenter une distance, un temps, un coût...
Arbres couvrants de poids
minimal
 A partir de la valuation d’un arc/arête, on peut définir la valuation d’un chemin / chaine :
c’est la somme des valuations des arcs/arêtes qui composent le chemin/chaine.
Définition:
Soit c(x, y) un chemin/chaîne dans G du sommet x vers y. La valuation ou poids du
chemin c(x, y) est v(x, y) = σu ∈ c(x,y) v(u).
 Si le graphe est valué, on définit le poids de l’arbre couvrant comme étant la somme
des poids de ses arêtes (ou arcs dans le cas orienté).
b 4 e
1
3 6
a 3 2
d
7 10
3
c 5
f
Poids de cet arbre est: 1+3+4+2+5=15

b 4 e
1
3 6
a 3 2
d
7 10
3
c 5
f

b 4 e
1
3 6
a 3 2
d
7 10
3
c 5
f
Poids de cet arbre est: 1+3+4+2+5=15 b 4 e

1
3 6
a 3 2
d
7 10
3
c 5
f

Algorithme de Kruskal
Principe :
On construit un sous-graphe en ajoutant des arêtes une par une. A chaque
étape, on cherche l’arête de plus petite valuation.
Algorithme :
S: ensemble des sommets, E: ensemble des arêtes et v les valuations des
arêtes.
F ← ∅ (F ensemble des arêtes de l’arbre couvrant)
Trier l’ensemble des arêtes de G pour les valuations croissantes
pour a ∈ E faire
si F ∪ {a} ne forme pas un cycle (acyclique)
F ←F ∪ {a}
fin si
fin pour
Exemple 4:
Considérons le graphe non orienté pondéré suivant:
a 3 c
7 4
4
b 1 e
9 9
d 5 f
En appliquant l’algorithme de Kruskal, construire un arbre couvrant de poids minimal

associé à ce graphe.
Etape 1: trier par ordre croissant les valuations des arêtes
Arêtes du graphe G (b,e) (a,c) (a,e) (c,e) (d,f) (a,b) (d,e) (e,f)
Poids 1 3 4 4 5 7 9 9
Etape 2: on construit l’arbre couvrant en prenant les arêtes les uns après les
autres dans l’ordre, en les ajoutant à l’arbre si elle ne créent pas de cycle.
a 3 c
7 4
4
b 1 e
9 9
d 5 f
Poids 1 3 4 4 5 7 9 9
Arêtes de l’arbre couvrant ✓

a 3 c
7 4
4
b 1 e
9 9
d 5 f
Poids 1 3 4 4 5 7 9 9
Arêtes de l’arbre couvrant ✓ ✓

a 3 c
7 4
4
b 1 e
9 9
d 5 f
Poids 1 3 4 4 5 7 9 9
Arêtes de l’arbre couvrant ✓ ✓ ✓

a 3 c
7 4
4
b 1 e
9 9
d 5 f
Poids 1 3 4 4 5 7 9 9
Arêtes de l’arbre couvrant ✓ ✓ ✓ ✘

a 3 c
7 4
4
b 1 e
9 9
d 5 f
Poids 1 3 4 4 5 7 9 9
Arêtes de l’arbre couvrant ✓ ✓ ✓ ✘ ✓

a 3 c
7 4
4
b 1 e
9 9
d 5 f
Poids 1 3 4 4 5 7 9 9
Arêtes de l’arbre couvrant ✓ ✓ ✓ ✘ ✓ ✘

a 3 c
7 4
4
b 1 e
9 9
d 5 f
Poids 1 3 4 4 5 7 9 9
Arêtes de l’arbre couvrant ✓ ✓ ✓ ✘ ✓ ✘ ✓

Etape 3: On s'arrête à ce niveau car on a construit un arbre couvrant contenant
n-1=5 arêtes.
a 3 c
7 4
4
b 1 e
9 9
d 5 f
Poids 1 3 4 4 5 7 9 9

a 3 c
7 4
4
b 1 e
9 9
d 5 f
a 3 c
b 1 e
d 5 f
Arbre couvrant de poids minimal

1+3+4+5+9=22
Que se passe-t-il si l’on inverse l’ordre des arêtes qui ont le même poids ?
Arêtes du graphe G (b,e) (a,c) (c,e) (a,e) (d,f) (a,b) (e,f) (d,e)
Poids 1 3 4 4 5 7 9 9
a 3 c
7 4
4
b 1 e
9 9
d 5 f
Poids 1 3 4 4 5 7 9 9
Arêtes de l’arbre couvrant ✓

a 3 c
7 4
4
b 1 e
9 9
d 5 f
Poids 1 3 4 4 5 7 9 9
Arêtes de l’arbre couvrant ✓ ✓

a 3 c
7 4
4
b 1 e
9 9
d 5 f
Poids 1 3 4 4 5 7 9 9
Arêtes de l’arbre couvrant ✓ ✓ ✓

a 3 c
7 4
4
b 1 e
9 9
d 5 f
Poids 1 3 4 4 5 7 9 9
Arêtes de l’arbre couvrant ✓ ✓ ✓ ✘

a 3 c
7 4
4
b 1 e
9 9
d 5 f
Poids 1 3 4 4 5 7 9 9
Arêtes de l’arbre couvrant ✓ ✓ ✓ ✘ ✓

a 3 c
7 4
4
b 1 e
9 9
d 5 f
Poids 1 3 4 4 5 7 9 9
Arêtes de l’arbre couvrant ✓ ✓ ✓ ✘ ✓ ✘

a 3 c
7 4
4
b 1 e
9 9
d 5 f
Poids 1 3 4 4 5 7 9 9

n-1=5 arêtes.
a 3 c
7 4
4
b 1 e
9 9
d 5 f
Poids 1 3 4 4 5 7 9 9

a 3 c
7 4
4
b 1 e
9 9
d 5 f
a 3 c
b 1 e
d 5 f

1+3+4+5+9=22
a 3 c a 3 c
4
4
b 1 e b 1 e
9 9
d 5 f d 5 f
Poids de chaque arbre 1+3+4+5+9=22

Algorithme de Prim
Principe:
On construit un sous-graphe en ajoutant des arêtes une par une. A chaque
étape, on cherche l’arête sortante de plus petite valuation. On termine dés
que l’on a sélectionner n − 1 arêtes.
Algorithme:
F←∅
M ← {x0} (on marque un sommet quelconque de G)
tant qu’il y ’a des arêtes sortantes de M, faire
chercher l’arête sortante a = (x, y) de plus petite valuation (x ∈ M et y /∉ M)
M ← M ∪ {y}
Exemple 5:
Considérons le graphe non orienté pondéré suivant:
a 3 c
7 4
4
b 1 e
9 9
d 5 f
En appliquant l’algorithme de Prim, construire un arbre couvrant de poids minimal

associé à ce graphe.
Etape 1: choisir n’importe quel sommet du graphe.
a 3 c
7 4
4
b 1 e
9 9
d 5 f
Etape 1: choisir n’importe quel sommet du graphe.
a 3 c
7 4
4
b 1 e
9 9
d 5 f
Etape 2: rajouter un sommet et une arête à l’arbre partiel où cette arête est de
poids minimal qui a une extrémité dans l’arbre et une hors de l’arbre.
a 3 c
7 4
4
b 1 e
9 9
d 5 f
a 3 c
7 4
4
b 1 e
9 9
d 5 f
a 3 c
7 4
4
b 1 e
9 9
d 5 f
a 3 c
✘
7 4
4
b 1 e
9 9
d 5 f
a 3 c
7 4
4
b 1 e
9 9
d 5 f
a 3 c
7 4
4
b 1 e
9 9
d 5 f
a 3 c
7 4
4
b 1 e
9 9
d 5 f
a 3 c
7 4
4
b 1 e
9 9
d 5 f
a 3 c
7 4
4
b 1 e
9 9
d 5 f
n-1=5 arêtes
a 3 c
7 4
4
b 1 e
9 9
d 5 f
a 3 c
b 1 e
d 5 f

1+3+4+5+9=22
Recherche de plus court
chemin
Problème de recherche de plus court chemin:

De nombreux problèmes concrètes se traduisent par la recherche d’un chemin
de longueur minimale.
- Rechercher de l’itinéraire le plus court ( valuation d’un arc=distance entre deux
villes) ou plus rapide (=temps pour parcours entre deux villes),
- Routage dans les réseaux, etc.
chemin
Définition:
Soit G = (S, A, v) et soient x et y deux sommets de G. On appelle distance entre
x et y et on note d(x, y), le minimum des valuations des chemins allant de x à y :
d(x, y) = min v(c(x, y)).
 S’il n’existe pas de chaine ou chemin entre x et y on pose d(x, y) = +∞

 On appelle le plus court chemin de x et y et on note c*(x, y) un chemin qui
réalise ce minimum : v (c*(x, y)) = d(x, y).
 IL se peut que le minimum n’existe pas, dans ce cas il est abusif de parler de
distance entre deux sommets, c’est ce qui arrive quand le graphe possède un
circuit absorbant ( cas d’un circuit a valuation négative).
a 2 c
-5 1
Il n’est pas possible de définir la distance entre a et b car il n’existe pas de

plus court chemin entre les deux sommets ( circuit absorbant).
En effet, v(a→ c→ b) = 3 et v(a→ c → b → a → c → b) = 1 et ainsi de
suite.
Nous allons dans la suite nous intéresser à des algorithmes qui cherchent le plus
courts chemin entre un sommet donné x0 et tous les autres sommets d’un
graphe. Les résultats seront stockés de la façon suivante :
1- Le tableau λ contient le plus court chemin de x0 à chaque sommet du graphe :
λ(i) = d(x0, i).
2- Le tableau π contient les prédécesseurs de chaque sommet dans le plus court
chemin à partir de x0.
Exemple:
a 2 c
3 5 1
b e
7 5
On cherche le plus court chemin à partir du sommet a vers un autre sommet

x après avoir calculé les plus courts chemins des prédécesseurs de x à partir
de a, on obtient les tableaux suivants :
i a c b d e
λ(i) 0 2 3 8 3
i a c b d e
π(i) null a a e c
chemin
Principe général des algorithmes:
Les trois algorithmes que nous allons étudier fonctionnent de la façon suivante :
- On initialise les tableaux λ et π (algorithme 1).
- On calcul les λ(s) et π(s) par approximations successives, ce qui signifie, à chaque
étape on essaye d’améliorer les valeurs obtenus précédemment..
L’amélioration au niveau local se vérifie ainsi; pour un sommet x et un sommet y, on
compare la valeur λ(y) obtenue à l’étape précédente avec la valeur qu’on obtiendrait en
passant par x. c- à-d. λ(x) + v (x, y), si cette dernière est plus petite alors on remplace
λ(y) par λ(x) + v (x, y) et le père π(y) par x. (technique de relâchement, algorithme 2).
chemin
Algorithme 1: ( Initialisation des algorithmes de recherche du plus court chemin)

Initialisation (G, x0)
pour i = 1 à n faire
λ(i) ← +∞
π(i) ← null
Fin pour
marquer x0
λ(x0) ← 0
Algorithme 2: ( Technique de relâchement)
Relâcher (G, i, j)
Si λ(j) > λ(i) + v(i, j) alors
λ(j)← λ(i) + v(i, j)
π(j)← i
Fin si
Algorithme de Dijkstra
Algorithme de Dijkstra: cet algorithme s’applique aux graphes dont les valuations
sont positives, c’est un algorithme glouton, à chaque étape, un nouveau sommet i sera
marqué ( les valeurs λ(i) et π(i) seront alors définitives), puis on utilisera la technique de
relâchement afin d’améliorer les chemins menant aux successeurs de i. Le nouveau
sommet sera choisi comme celui dont la valeur depuis x0 est minimal parmi tous les
sommets non encore marqués. En effet, on est assuré que les résultats pour ce sommet
ne pourront pas être améliorer car :
- Les chemins passant par des sommets déjà tous marqués ont été pris en compte
dans la valeur actuelle λ(i).
- Un chemin passant par un sommet non encore marqué sera nécessairement de
poids supérieur puisque on a choisi i tel que λ(i) est minimal et que les valuations des
arcs sont positives.
Algorithme de Dijkstra
Algorithme: Dijkstra (G, x0)

Initialisation (G, x0)
E ← ∅ ( E ensemble des sommets marqués)
tant que e≠ s faire
i, un sommet non marqué tel que λ(i) est minimal.
marquer le sommet i
pour tout j ∈ г+(i) faire
si j n’est pas marqué
relâcher (g, i, j)
fin si
fin pour
E←E ∪ {i}
fin tant que

Théorie Des Graphes Chap 2 Et Chap 3

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Théorie Des Graphes Chap 2 Et Chap 3

Transféré par

Droits d'auteur :

Formats disponibles

RESPONSABLE: SANAE MOUSSAOUI

En utilisant un graphe comme modèle, beaucoup de problèmes sur les graphes

Il existe deux types d’explorations:

 S’il n’existe pas de chaine ou chemin entre x et y on pose d(x, y) = +∞

1 4 d(1,2)=1, d(2,3)=2, d(1,4)=2

Enfiler Obj3 Obj2 Obj1 Défiler

Algorithme BFS : Breadth First Search

En appliquant l’algorithme de parcours en largeur à partir de la racine 1, on obtient:

Plus courte chaîne

1- Faire un parcours en largeur du graphe

2- Colorier les niveau pairs en rouge et les niveaux

3- Tester si aucun arc/arête entre les sommets d’un même

3- Tester si aucun arc/arête entre les sommets d’un même

3- Tester si aucun arc/arête entre les sommets d’un même

3- Tester si aucun arc/arête entre les sommets d’un même

Alors, le graphe est biparti.

Liste d’adjacence décroissante

Liste d’adjacence croissante 1

À ce stade, nous tournons à droite jusqu'à atteindre une bifurcation.

Ensuite, nous revenons à la dernière intersection, et nous continuons

Supposons que nous rencontrions cette situation, comment

1- Tout d'abord, on peut représenter notre

2- Chaque intersection sera représentée par un

 Implémentation de l’algorithme DFS récursivement

Algorithme DFS : Depth First Search ( récursive)

Procédure DFS-Visiter(G: graphe,U: sommet)

En appliquant l’algorithme de parcours en Profondeur, on obtient:

Arborescence de racine 1 Arborescence de racine 7

Représentation en machine d’un 1-graphe

Algorithme DFS : Depth First Search ( en utilisant la pile)

Appliquer l’algorithme de parcours en Profondeur en utilisant les piles.

Sous arbre enraciné en 1

Est-il fortement connexe?

Poids de cet arbre est: 1+3+4+2+5=15

Poids de cet arbre est: 1+3+3+4+2=13

Poids de cet arbre est: 1+3+4+2+5=15 b 4 e

Poids de cet arbre est: 1+3+3+4+2=13

En appliquant l’algorithme de Kruskal, construire un arbre couvrant de poids minimal

Etape 1: trier par ordre croissant les valuations des arêtes

Arêtes de l’arbre couvrant ✓

Arêtes de l’arbre couvrant ✓ ✓

Arêtes de l’arbre couvrant ✓ ✓ ✓

Arêtes de l’arbre couvrant ✓ ✓ ✓ ✘

Arêtes de l’arbre couvrant ✓ ✓ ✓ ✘ ✓

Arêtes de l’arbre couvrant ✓ ✓ ✓ ✘ ✓ ✘

Arêtes de l’arbre couvrant ✓ ✓ ✓ ✘ ✓ ✘ ✓

Arêtes de l’arbre couvrant ✓ ✓ ✓ ✘ ✓ ✘ ✓

Arbre couvrant de poids minimal

Arêtes de l’arbre couvrant ✓

Arêtes de l’arbre couvrant ✓ ✓

Arêtes de l’arbre couvrant ✓ ✓ ✓

Arêtes de l’arbre couvrant ✓ ✓ ✓ ✘

Arêtes de l’arbre couvrant ✓ ✓ ✓ ✘ ✓

Arêtes de l’arbre couvrant ✓ ✓ ✓ ✘ ✓ ✘

Arêtes de l’arbre couvrant ✓ ✓ ✓ ✘ ✓ ✘ ✓

Arêtes de l’arbre couvrant ✓ ✓ ✓ ✘ ✓ ✘ ✓

Arbre couvrant de poids minimal

Poids de chaque arbre 1+3+4+5+9=22

En appliquant l’algorithme de Prim, construire un arbre couvrant de poids minimal

Arbre couvrant de poids minimal

Problème de recherche de plus court chemin:

 S’il n’existe pas de chaine ou chemin entre x et y on pose d(x, y) = +∞

Il n’est pas possible de définir la distance entre a et b car il n’existe pas de

On cherche le plus court chemin à partir du sommet a vers un autre sommet