Chap08 Les graphes - Parcours.

Ecole Royale Navale - CPGE

Page 1 de 12 MP - Informatique

Chap08 Les graphes - Parcours

Gossoni Mohamed
mohamedgossoni@gmail.com
L’Ecole Royale Navale - CPGE - 2ème année MP

Plan
Introduction:
I - Parcours en profondeur:
1. Principe:
2. Algorithme:
3. Complexité:
II - Parcours en largeur:
1. Principe:
2. Algorithme:
3. Complexité:
III - Le plus court chemin:
1. Présentation du problème:
a- Exemple:
b- Une modélisation:
2. Dijkstra:
a- Principe:
b- Algorithme:
c- Complexité

1 Introduction:
Dans ce chapitre on présente 2 algorithmes de parcours de graphe: Les algorithmes de parcours
permettent de mettre en évidence plusieurs caractéristiques de la structure du graphe. De nombreux
algorithmes utilisent le résultat d’un parcours pour obtenir ces informations structurelles sur le
graphe d’entrée. D’autres sont simplement des adaptations d’algorithmes élémentaires de parcours
de graphes.
Dijkstra, le troisième algorithme du chapitre, est l’un des algorithmes qui utilise un principe de
parcours pour résoudre le problème de plus court chemin entre 2 sommets d’un graphe pondéré.

1
 Chap08 Les graphes - Parcours. Ecole Royale Navale - CPGE
Page 2 de 12 MP - Informatique

Les techniques de parcours de graphe sont au cœur des algorithmes de graphes, elles peuvent être
utilisées pour déterminer entre autre:
• Le chemin le plus court entre deux sommets.
• Si un graphe est connexe.
• Les composantes connexes d’un graphe.
• Les cycles dans un graphe.
Sans perte de généralité, on traitera dans ce chapitre le cas d’un graphe non orienté. Pour un graphe
orienté il suffit de remplacer le mot 𝑣𝑜𝑖𝑠𝑖𝑛 par 𝑠𝑢𝑐𝑐𝑒𝑠𝑠𝑒𝑢𝑟, 𝑎𝑟𝑒𝑡𝑒 ̂ par 𝑎𝑟𝑐 et 𝑐𝑦𝑐𝑙𝑒 par 𝑐𝑖𝑟𝑐𝑢𝑖𝑡.
À titre d’exemples, on considère les 2 graphes:
• 𝐺1:
L1=[ [1,4], [0,2,4], [1,4,6], [5], [0,1,2], [3], [2] ]
M1=[[0, 1, 0, 0, 1, 0, 0],
[1, 0, 1, 0, 1, 0, 0],
[0, 1, 0, 0, 1, 0, 1],
[0, 0, 0, 0, 0, 1, 0],
[1, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0]]
• 𝐺2:
toNum={'Casablanca':0,'Rabat':1,'Settat':2,'El Jadida':3,'Mohammadia':4,'Salé':5,'Khouribga':6}
toAlph={0:'Casablanca',1:'Rabat',2:'Settat',3:'El Jadida',4:'Mohammadia',5:'Salé',6:'Khouribga'}
L2=[ [(1,95),(2,44),(3,75),(4,33),(6,86)],
[(0,95),(4,67),(5,24),(6,135)],
[(0,44),(3,110),(6,50)],
[(0,75),(2,110)],
[(0,33),(1,67)],
[(1,24)],
[(0,86),(1,135),(2,50)] ]
M2=[[0 ,95 ,44 ,75 ,33 ,0 ,86 ],
[95 ,0 ,0 ,0 ,67 ,24 ,135],
[44 ,0 ,0 ,110,0 ,0 ,50 ],
[75 ,0 ,110,0 ,0 ,0 ,0 ],
[33 ,67 ,0 ,0 ,0 ,0 ,0 ],
[0 ,24 ,0 ,0 ,0 ,0 ,0 ],
[86 ,135,50 ,0 ,0 ,0 ,0 ] ]

Exercice 1: Soit 𝐺 un graphe orienté ou non, pondéré ou non, représenté par sa liste d’adjacence
𝐿 ou sa matrice d’adjacence 𝑀 .
1. Écrire la fonction 𝑎𝑑𝑗𝐿𝑖𝑠𝑡(𝐿, 𝑠) qui retourne la liste de sommets adjacents du sommet 𝑠 à
partir d’une liste d’adjacence. (Dans le ca pondéré on obtiendra des couples (𝑠𝑜𝑚𝑚𝑒𝑡, 𝑝𝑜𝑖𝑑𝑠)
).
2. Écrire la version 𝑎𝑑𝑗𝑀 𝑎𝑡(𝑀 , 𝑠) qui traite une matrice d’adjacence 𝑀 au lieu d’une liste
d’adjacence.

2
Chap08 Les graphes - Parcours. Ecole Royale Navale - CPGE
Page 3 de 12 MP - Informatique

3. Application: Retourner la liste de sommets adjacents à 𝑠 = 2 en utilisant 𝐿1 puis en utilisant

𝑀 1.

2 Parcours en profondeur (Depth first search ):

2.1 Principe:
Le parcours en profondeur d’un graphe 𝐺 = (𝑉 , 𝐸) non orienté se réalise en partant d’un sommet
arbitraire 𝑠 et en parcourant d’abord 𝑢1 un de ses adjacents et 𝑢2 un des adjacents de 𝑢1 non
visité et …etc. Si on arrive à un sommet 𝑢𝑖 où tous ses adjacents sont visités, on “remonte” à 𝑢𝑖−1
son “prédécesseur” au sens du parcours. L’opération se répète récursivement pour chaque sommet
visité. On arrête lorsque tous les sommets accessibles sont visités.
On pourra bien utiliser :
• Une fonction récursive.
• Une version itérative en utilisant une pile pour stocker les sommets en traitement.

2.1.1 Exemple 1

2.2 Algorithmes:
2.2.1 Algorithme récursif
# Algo principal.
function: profRec(L,s,visite,parcours).
in : L la liste (adjacence) du graphe.
s le sommet en cours de traitement.
Visite la liste des états de sommets (visité: oui ou non).
Parcours la liste de parcours en construction.
out: Achever la liste Parcours du parcours en profondeur.
Ajouter s à Parcours
Visite[s] ← Vrai # s est visité
Adj ← Liste des adjacents de s
Pour chaque a dans Adj Faire:

3
Chap08 Les graphes - Parcours. Ecole Royale Navale - CPGE
Page 4 de 12 MP - Informatique

Si a est non visité Alors:

profRec(L,a,Visite,Parcours)

# Initialisation avant l'appel de la fonction:

s ← Le sommet de départ
Parcours ← []
Visite[i] ← False pour tout sommet i

2.2.2 Version iterative

function: profIt(L,s)
in : L la liste (adjacence).
s le sommet de départ.
out: La liste parcours du parcours en profondeur.
# Initialisation avant la boucle:
Parcours ← [s]
Visite[i] ← Faux pour tout sommet i.
Visite[s] ← Vrai
Pile ← []
Empiler s dans Pile
Tant que Pile est non vide Faire:
d ← Lire le sommet de la pile P
Adj ← Liste des adjacents de d
Pour chaque a dans Adj:
Si a non visité Alors: # Recherche du premier a non visité
Ajouter a dans Parcours
Empiler a dans Pile
Visite[a] ← Vrai # a est visité.
Sortir de la boucle for
Si a non trouvé: # Si la boucle "Pour" termine normalement
Dépiler Pile
Retourner parcours

Exercice 2
• En se référant à l’algorithme, écrire les fonctions 𝑝𝑟𝑜𝑓𝑅𝑒𝑐𝐿𝑖𝑠𝑡(𝐿, 𝑠) et 𝑝𝑟𝑜𝑓𝑅𝑒𝑐𝑀 𝑎𝑡(𝑀 , 𝑠)
récursives qui prennent en argument 𝑠 un sommet de départ et la liste d’adjacence 𝐿 (resp.
la matrice d’adjacence 𝑀 ) d’un graphe non pondéré et retourne la liste du parcours en
profondeur de ce graphe.
• Appliquer ces fonctions sur le graphe 𝐺1 et le sommet 0.

Exercice 3
• En se référant à l’algorithme, écrire les fonctions 𝑝𝑟𝑜𝑓𝐼𝑡𝐿𝑖𝑠𝑡(𝐿, 𝑠) et 𝑝𝑟𝑜𝑓𝐼𝑡𝑀 𝑎𝑡(𝑀 , 𝑠) itéra-
tives qui prennent en argument 𝑠 un sommet de départ et la liste d’adjacence 𝐿 (resp. la
matrice d’adjacence 𝑀 ) d’un graphe et retourne la liste du parcours en profondeur de ce
graphe.
• Appliquer ces fonctions sur le graphe 𝐺1 et le sommet 0.

4
Chap08 Les graphes - Parcours. Ecole Royale Navale - CPGE
Page 5 de 12 MP - Informatique

2.3 Complexité:
function: profIt(L,s) # Matrice d'adjacence # Liste d'ajacence
Parcours ← [s] # O(1)
Visite[i] ← Faux pour tout sommet i. # O(|S|)
Visite[s] ← Vrai # O(1)
Pile ← [] # O(1)
Empiler s dans Pile # O(1)
Tant que Pile est non vide Faire: # O(|S|) (Chaque sommet est empilé
# et dépilé une fois)
d ← Lire le sommet de la pile P # O(1)
Adj ← Liste des adjacents de d # O(|S|) # O(1)
Pour chaque a dans Adj: # O(|A|) (Tant que + Pour: Somme des
# deg(d) où d varie dans S)
Si a non visité Alors: # O(1)
Ajouter a dans Parcour # O(1)
Empiler a dans Pile # O(1)
Visite[a] ← Vrai # O(1)
Sortir de la boucle for # O(1)
Si a non trouvé: # O(1)
Dépiler Pile # O(1)
Retourner parcours # O(1)
Si l’on suppose que le graphe est connexe alors dans le pire des cas on a la complexité:
• 𝑂(|𝑆|2 + |𝐴|):
– Cas d’une représentation par Matrice d’adjacence.
• 𝑂(|𝑆| + |𝐴|):
– Cas d’une représentation par Liste d’adjacence.
3 Parcours en largeur (Breadth first search):
3.1 Principe:
Le parcours en largeur d’un graphe 𝐺 = (𝑉 , 𝐸) orienté ou non, est un parcours par “niveau”, il se
réalise en partant d’un sommet arbitraire 𝑠 et on visite tous ses adjacents puis les adjacents de
ses adjacents non visités etc…, et lorsque un niveau est épuisé, on passe au niveau (plus ptrofond)
suivant jusqu’à ce que tous les sommets aient été couverts. On utilisera donc :
• Une file pour stocker les sommets du prochain niveau à traiter.
3.1.1 Exemple 2

5
Chap08 Les graphes - Parcours. Ecole Royale Navale - CPGE
Page 6 de 12 MP - Informatique

3.2 Algorithmes:
function: larg(L,s)
in : L la liste ou matrice (adjacence).
s le sommet de départ.
out: La liste Parcours du parcours en largeur.
# Initialisation avant la boucle:
Parcours ← [s]
Visite[i] ← Faux pour tout sommet i.
Visite[s] ← Vrai
File ← []
File ← s Enfiler
Tant File est non vide Faire:
d ← Défiler la tête de File
Adj ← Liste des adjacents de d
Pour chaque a dans Adj:
Si a non visité Alors: # Recherche de tout adjacent a non visité
Ajouter a dans Parcours
Enfiler a dans File
Visite[a] ← Vrai # a est visité.
Retourner parcours
3.2.1 Remarque: [Le module 𝑐𝑜𝑙𝑙𝑒𝑐𝑡𝑖𝑜𝑛𝑠.𝑑𝑒𝑞𝑢𝑒]
1. En implémentant les Piles et les Files par l’utilisation des Listes de Python, on a:
• Les méthodes Empiler (𝑃 𝑖𝑙𝑒.𝑎𝑝𝑝𝑒𝑛𝑑(𝑎)) et Dépiler (𝑃 𝑖𝑙𝑒.𝑝𝑜𝑝()) ont pour coût 𝑂(1).
• La méthode Enfiler (𝐹 𝑖𝑙𝑒.𝑎𝑝𝑝𝑒𝑛𝑑(𝑎)) a pour coût 𝑂(1) alors que Défiler (𝐹 𝑖𝑙𝑒.𝑝𝑜𝑝(0)) a
pour coût 𝑂(|𝑆|) où |𝑆| est l’ordre du graphe.
2. Les 𝑑𝑒𝑞𝑢𝑒𝑠 sont une généralisation des Piles et des Files (deque se prononce “dèque” et est
l’abréviation de l’anglais double-ended queue) : il est possible d’ajouter et retirer des éléments
par les deux bouts des deques.
• Celles-ci gèrent des ajouts et des retraits efficients du point de vue de la mémoire des
deux côtés de la 𝑑𝑒𝑞𝑢𝑒, avec approximativement la même performance en 𝑂(1) dans les
deux sens.
• Pour nous, ça va nous permettre d’effectuer des Défilements (𝐹 𝑖𝑙𝑒.𝑝𝑜𝑝(0)) en 𝑂(1))

from collections import deque

D = deque(it) # Créer un deque à partir d'un itérable
# it (Liste, chaîn de caractère, ...)
D = deque([]) # Initialisation d'un deque à vide
D.append(a) # Enfilement ou Empilement de a
f=D.popleft() # Défilement de la queue de la file
# Au lieu de pop(0) pour une liste
p=D.popright() # Dépilement du sommet de la pile
# Au lieu de pop(-1) pour une liste
if D != deque([]): # Si la deque n'est pas vide
< instructions> # bloc de if

6
Chap08 Les graphes - Parcours. Ecole Royale Navale - CPGE
Page 7 de 12 MP - Informatique

3.3 Complexité:
function: larg(L,s) # File à base de liste # File à base de deque
Parcours ← [s] # O(1)
Visite[i] ← Faux pour tout sommet i. # O(|S|)
Visite[s] ← Vrai # O(1)
File ← [] # O(1)
File ← s Emfiler # O(1)
Tant File est non vide Faire: # O(|S|) (Chaque sommet est enfilé
# et défilé une fois)
d ← Défiler la tête de File # O(|S|) # O(1)
Adj ← Liste des adjacents de d # O(|S|) cas Matrice, O(1) cas Liste
Pour chaque a dans Adj: # O(|A|) (Tant que + Pour: Somme des
# deg(d) où d varie dans S)
Si a non visité Alors: # O(1)
Ajouter a dans Parcours # O(1)
Enfiler a dans File # O(1)
Visite[a] ← Vrai # O(1)
Retourner parcours # O(1)
Si l’on suppose que le graphe est connexe alors dans le pire des cas on a la complexité:
• 𝑂(|𝑆|2 + |𝐴|):
– Cas d’une File à base de 𝑙𝑖𝑠𝑡 et une représentation par Liste ou Matrice d’adjacence.
– Cas d’une File à base de 𝑑𝑒𝑞𝑢𝑒 et une représentation par Matrice d’adjacence.
• 𝑂(|𝑆| + |𝐴|):
– Cas d’une File à base de 𝑑𝑒𝑞𝑢𝑒 et une représentation par Liste d’adjacence.

Exercice 4
• En se référant à l’algorithme et en utilisant une file deque, écrire les fonctions 𝑙𝑎𝑟𝑔𝐿𝑖𝑠𝑡(𝐿, 𝑠)
et 𝑙𝑎𝑟𝑔𝑀 𝑎𝑡(𝑀 , 𝑠) itératives qui prennent en argument 𝑠 un sommet de départ et la liste
d’adjacence 𝐿 (resp. la matrice d’adjacence 𝑀 ) d’un graphe non pondéré et retourne la liste
du parcours en largeur de ce graphe.
• Appliquer ces fonctions sur le graphe 𝐺1 et le sommet 0.

4 Le plus court chemin:

4.1 Présentation du problème:
On se trouve souvent dans une situation semblable à celle décrite par l’exemple suivant:

7
Chap08 Les graphes - Parcours. Ecole Royale Navale - CPGE
Page 8 de 12 MP - Informatique

4.1.1 Exemple:

Exemple 3 Quelles sont les chemins les plus courts (en kilomètre) de Settat aux autres vile de
la carte?
On peut répondre à la question par un simple calcul, mais lorsque la situation est beaucoup plus
compliqué, il nous faudra une modélisation mathématique formant une base à un algorithme efficace.

4.1.2 Une modélisation:

• On considère un graphe pondéré 𝐺 = (𝑉 , 𝐸, 𝑃 ) où 𝑃 est l’ensemble de poids (valeurs réelles
positives), qu’on considéra des distances 𝑑(𝑠1 , 𝑠2 ) associés aux arêtes (arcs) 𝑠1 𝑠2 de 𝐸.
• On définit et on note la distance d’un chemin (chaîne) 𝐶𝑠,𝑡 allant d’un sommet 𝑠 fixé à un
autre sommet 𝑡 par 𝑑[𝑡] = ∑ 𝑑(𝑥, 𝑦).
𝑥𝑦∈𝐶𝑠,𝑡
• On note la distance du plus court chemin (chaîne) allant du sommet 𝑠 fixé à un autre sommet
𝑡 par 𝛿(𝑡). On a donc toujours 𝛿(𝑡) ≤ 𝑑[𝑡].
• En fin si 𝑉𝑟 l’ensemble d’adjacents du sommet 𝑟, on a la relation récurrente:

𝛿(𝑠) = 0
{ 𝛿(𝑟) = 𝑀 𝑖𝑛{𝛿(𝑡) + 𝑑(𝑡, 𝑟)} 𝑟 ≠ 𝑠 (∗)
𝑡∈𝑉𝑟

8
Chap08 Les graphes - Parcours. Ecole Royale Navale - CPGE
Page 9 de 12 MP - Informatique

4.2 Algorithme de Dijkstra:

Dijkstra est parmi les algorithmes qui détermine le plus court chemin (chaîne) et il a les particu-
larités suivantes:
• Il fait partie des algorithme glouton: On fait des choix locaux optimaux et irréversible. ( Voir
Chap09 suivant)
• Opère sur un graphe (orienté ou non) pondéré de poids positifs.
• Détermine les plus courts chemins (chaînes) à source unique: d’un sommet 𝑠 fixé vers tous
les autres sommets.
• Utilise le principe du parcours en largeur (les adjacents d’abord).

4.2.1 Principe:
On considère:
• un sommet 𝑠 source.
• 2 ensembles: 𝑇 𝑟𝑎𝑖𝑡𝑒𝑠́ de sommets traités et 𝑁 𝑜𝑛𝑇 𝑟𝑎𝑖𝑡𝑒𝑠́ = 𝑉 − 𝑇 𝑟𝑎𝑖𝑡𝑒𝑠́ de sommets à traiter.
• Une liste 𝑑 où 𝑑[𝑖] modélise la distance provisoire du plus court chemin (chaîne) de 𝑠 à 𝑖.
• Une liste 𝑝𝑟𝑒𝑑 où 𝑝𝑟𝑒𝑑[𝑖] modélise le prédécesseur de 𝑖 dans le plus court chemin (chaîne)
provisoire de 𝑠 à 𝑖.

9
Chap08 Les graphes - Parcours. Ecole Royale Navale - CPGE
Page 10 de 12 MP - Informatique
Etapes:
1. On commence par traiter 𝑠.
2. A chaque itération on extrait un sommet 𝑡 de 𝑁 𝑜𝑛𝑇 𝑟𝑎𝑖𝑡𝑠 qui a la distance minimale 𝑑[𝑡] puis
on mis à jours les distances de ses adjacents selon la relation (∗). A la fin de cette étape 𝑑[𝑡]
deviendra la distance finale 𝛿(𝑡).
3. Lorsque 𝑁 𝑜𝑛𝑇 𝑟𝑎𝑖𝑡𝑠 est vide toutes les distances sont minimales.

Exercice 5 Écrire la fonction 𝑒𝑥𝑡𝑟𝑎𝑖𝑟𝑒𝑀 𝑖𝑛(𝑑, 𝐿) qui prend en paramètre les 2 listes 𝑑 et 𝐿 et qui
retourne 𝑡𝑚𝑖𝑛 de la liste 𝐿 tel que 𝑑[𝑡𝑚𝑖𝑛] = 𝑚𝑖𝑛{𝑑[𝑡], 𝑡 ∈ 𝐿}.

4.2.2 Algorithme Dijkstra(𝐺, 𝑠):

function: Dijkstra(G,s)
in : G la liste ou la matrice (adjacence) du graphe.
s le sommet source.
out: pred la liste des prédécesseurs de chemins.
d la liste de distances minimales.
Initialistion:
d initialisée par Infini pour chaque sommet.
pred initialisée par Nul pour chaque sommet.
d[s] ← 0
NonTraités ← tous les sommets
Itérations:
Tant que NonTraités est non vide Faire:
Extraire un t de NonTraités avec d[t] est minimum
Adj ← Liste des adjacents de t
Pour tout r dans Adj :
Si d[t]+d(t,r)<d[r] Alors:
d[r]=d[t]+d(t,r)
pred[r]=t
Fin:
Retourner pred , d

Exercice 6 En se référant à l’algorithme et en utilisant 𝑒𝑥𝑡𝑟𝑎𝑖𝑟𝑒𝑀 𝑖𝑛 écrire la fonction

𝑑𝑖𝑗𝑘𝑠𝑡𝑟𝑎𝑀 𝑎𝑡(𝑀 , 𝑠) qui prend en paramètre un graphe représenté par sa matrice d’adjacence 𝑀 et
𝑠 un sommet du graphe et qui retourne une liste de prédécesseurs 𝑝𝑟𝑒𝑑 et une liste 𝑑 de distances
des plus courts chemin entre de 𝑠 à chaque sommet du graphe.
Indication: On initialisera la liste 𝑑 par la valeur 𝑓𝑙𝑜𝑎𝑡("𝑖𝑛𝑓") qui représente en Python ∞.

Exemple 4 Appliquons l’algorithme sur l’exemple 11 avec le sommet source est 𝑣2 (Settat) et en
déduisons le plus court chemin entre 𝑣2 (Settat) et 𝑣5 (Salé).

10
Chap08 Les graphes - Parcours. Ecole Royale Navale - CPGE
Page 11 de 12 MP - Informatique

La réponse est donc:

• La plus courte distance est 163.
• Le plus court chemin est: 5 = 𝑆𝑎𝑙 < − − 𝑝𝑟𝑒𝑑(5) = 1 ∶ 𝑅𝑎𝑏𝑎𝑡 < − − 𝑝𝑟𝑒𝑑(1) = 0 ∶
𝐶𝑎𝑠𝑎𝑏𝑙𝑎𝑛𝑐𝑎 < − − 𝑝𝑟𝑒𝑑(0) = 2 ∶ 𝑆𝑒𝑡𝑡𝑎𝑡.

Exercice 7
1. Écrire une fonction 𝑝𝑙𝑢𝑠𝐶𝑜𝑢𝑟𝑡𝐶ℎ𝑒𝑚𝑖𝑛(𝑀 , 𝑥, 𝑦) qui prend en paramètre la matrice 𝑀
d’adjacence d’un graphe et 2 sommets 𝑥 et 𝑦 et retourne la liste du plus court chemin de
𝑦 à 𝑥 (inversée) et la valeur de sa distance.
2. Appliquer pour retrouver le résultat de l’exemple précédent (Exemple 4).

4.2.3 Complexité:
function: Dijkstra(G,s) # Matrice # Liste
Initialistion:
d initialisée par Infini pour chaque sommet. # O(|S|)
pred initialisée par Nul pour chaque sommet. # O(|S|)
d[s] ← 0 # O(1)
NonTraités ← tous les sommets # O(|S|)
Itérations:
Tant que NonTraités est non vide Faire: # O(|S|)
Extraire un t de NonTraités avec d[t] est minimum # O(|S|) cas NonTraités
# est une liste,
# O(log(|S|) cas NonTraités
# est une file-priorité
Adj ← Liste des adjacents de t # O(|S|) # O(1)

11
Chap08 Les graphes - Parcours. Ecole Royale Navale - CPGE
Page 12 de 12 MP - Informatique

Pour tout r dans Adj Faire: # O(|A|) (Tant que + Pour:

# Somme des deg(t)
# où t varie dans S)
Si d[t]+d(t,r)<d[r] Alors: # O(1)
d[r]=d[t]+d(t,r) # O(1)
pred[r]=t # O(1)
Fin:
Retourner pred , d # O(1)
Si l’on suppose que le graphe est connexe alors dans le pire des cas on a la complexité:
• 𝑂(|𝑆|2 + |𝐴|):
– Cas de 𝑁 𝑜𝑛𝑇 𝑟𝑎𝑖𝑡𝑒 est une Liste et le graphe est représenté par une Matrice ou Liste
d’adjacence.
• 𝑂(|𝑆|𝑙𝑜𝑔(|𝑆|) + |𝐴|):
– Cas de 𝑁 𝑜𝑛𝑇 𝑟𝑎𝑖𝑡𝑒 est une File de priorité et le graphe est représenté par une Liste
d’adjacence.

12