CSI2510 Structures de données et algorithmes Plus court chemin

Présentation au sujet: "CSI2510 Structures de données et algorithmes Plus court chemin"— Transcription de la présentation:

1 CSI2510 Structures de données et algorithmes Plus court chemin

2 Graphe pondéré Les poids des arêtes d’un graphe représentent des distances, des coûts, etc. Exemple d’un graphe pondéré non-orienté: Dans un graphe des route aériennes, le poids d'une arête représente la distance en miles entre les aéroports de chaque extrémité 849 PVD 1843 ORD 142 SFO 802 LGA 1743 1205 337 1387 HNL 2555 1099 LAX 1233 DFW 1120 MIA CSI PCC

3 Plus court chemin Étant donné un graphe pondéré et deux sommets u et v, nous voulons trouver un chemin de poids total minimal entre u et v Applications Les réservations de vol Directions de conduite Routage des paquets d‘Internet Exemple: Plus court chemin entre Providence et Honolulu 849 PVD 1843 ORD 142 SFO 802 LGA 1743 1205 337 1387 HNL 2555 1099 LAX 1233 DFW 1120 MIA CSI PCC

4 Propriétés Propriété 1: Propriété 2: Exemple:
Un sous-chemin d’un plus court chemin est aussi un plus court chemin Propriété 2: L’ensemble des plus courts chemins d’un sommet à tous les autres sommets forme un arbre Exemple: Un arbre des plus courts chemins de Providence 849 PVD 1843 ORD 142 SFO 802 LGA 1743 1205 337 1387 HNL 2555 1099 LAX 1233 DFW 1120 MIA CSI PCC

5 Algorithme de Dijkstra
La distance entre un sommet v à un autre sommet s est la longueur du plus court chemin entre s et v L’algorithme de Dijkstra calcule la distance entre un sommet donnée s de départ et tous les autres sommets Suppositions: Le graphe est connexe Les arêtes sont non-orientées Les poids des arêtes sont non-négatifs CSI PCC

6 Algorithme de Dijkstra
L’algorithme conserve l’ensemble des sommets pour lesquels la distance a été calculée, appelé nuage (cloud) C On fait grossir un “nuage” de sommets, contenant au départ s et couvrant éventuellement tous les sommets Pour chaque sommet v nous emmagasinons d(v) = La plus courte distance entre v et s dans le sous-graphe constitué du nuage et de ses sommets adjacents. A 4 8 2 2 4 8 7 1 B C D Exemple 3 9 5 2 E F CSI PCC  

7 3 --> chemin plus court!
Algorithme de Dijkstra Pour chaque étape: Nous ajoutons au nuage le sommet extérieur u qui a la plus petite étiquette de distance Nous mettons à jour les étiquettes des sommets adjacents à u Dans l’exemple … A 4 8 2 A 4 8 2 8 4 7 1 2 B C D 8 2 4 3 --> chemin plus court! 8 7 1 B C D 3 9 2 5 E F 3 9 2 5   E F   5 - chemin plus court! 11 - chemin plus court! CSI PCC

8 Mise à jour = la relaxation des arêtes
Algorithme de Dijkstra Mise à jour = la relaxation des arêtes Considérer une arête e = (u,z) telle que: u est le sommet le plus récemment ajouté au nuage z n’est pas dans le nuage La relaxation d’une arête e consiste a mettre à jour la distance d(z) comme suit: d(u) = 50 d(z) = 75 10 u s z d(u) = 50 10 d(z) = 60 u s z d(z)  min( d(z), d(u) + poids(e) ) CSI PCC

9 Exemple C B A E D F 3 2 8 5 4 7 1 9 A 4 8 2 8 2 4 7 1 B C D 3 9   2 5 E F A 4 A 4 8 8 2 2 8 2 3 7 2 3 7 1 7 1 B C D B C D 3 9 3 9 5 11 5 8 2 5 2 5 E F E F CSI PCC

10 Exemple (suite) A 4 8 2 7 2 3 7 1 B C D 3 9 5 8 2 5 E F A 4 8 2 7 2 3
A 4 8 2 7 2 3 7 1 B C D 3 9 5 8 2 5 E F A 4 8 2 7 2 3 7 1 B C D 3 9 5 8 2 5 E F CSI PCC

11 Algorithme de Dijkstra
Nous emmagasinons les sommets, qui ne sont pas dans le nuage, dans une file de priorité Q. élément: un sommet v clé: D[v] la distance du sommet CSI PCC

12 Algorithme de Dijkstra
Algorithm ShortestPath(G, v): Entrés : Un graphe pondéré G et un sommet particulier v de G. Sortie : Une étiquette D[u], pour chaque sommet u de G, telle que D[u] est la longueur d'un plus court chemin de v à u dans G. initialise D[v]  0 et D[u]  ∞ pour chaque sommet v  u Soit Q une file à priorité qui contient tous les sommets de G utilisant les étiquettes de D comme clés. while Q   do {insérer u dans le nuage C} u  Q.removeMinElement() pour chaque sommet z adjacent à u tel que z est dans Q faire {exécuter l'opération de relaxation sur l’arête (u, z) } Si D[u] + w((u, z)) < D[z] alors D[z] D[u] + w((u, z)) changer la valeur de la clé de z dans Q à D[z] Retourner l’étiquette D[u] de chaque sommet u. CSI PCC

13 Même exemple, avec un tas
  D Même exemple, avec un tas A B C D E F A 4 8 2 8 2 4 7 1 (A,C) 2 B C D 3 9   2 5 E F (A,B) 8 (A,D) 4 RemoveMin() et mise-a-jour A 4 8 2 8 2 3 7 1 B C D 3 9 5 11 2 5 E CSI PCC F

14 D Relaxation: (A,D) 4 RemoveMin() (A,B) 8 A 4 8 2 8 2 3 7 1 B C D
  D A B C D E F (A,D) 4 RemoveMin() (A,B) 8 A 4 8 2 8 2 3 7 1 B C D Relaxation: (C,D) 3 YES (3 < 4) 3 9 Mise-a-jour: 5 11 2 5 E F (C,E) 5 YES (5 < ) (C,F) 11 YES (11 < ) (C,B) NON (9>8) CSI PCC

15 D Remplacer (A,D) 4 avec (C,D) 3 Insert (C,E) 5 Insert (C,F) 11
  D A B C D E F (A,D) 4 Mise à jour signifie: enlever les anciennes clés et remplacer par les nouvelles (C,D) 3 au lieu de 4 (A,B) 8 au lieu de  (C,E) 5 (C,F) 11 au lieu de  Remplacer (A,D) 4 avec (C,D) 3 Insert (C,E) 5 Insert (C,F) 11 CSI PCC

16 Remplacer (A,D) 4 avec (C,D) 3
  D A B C D E F Mise à jour signifie: enlever les anciennes clés et remplacer par les nouvelles (C,D) 3 (C,D) 3 au lieu de 4 (A,B) 8 au lieu de  (C,E) 5 (C,F) 11 au lieu de  Quand on doit remplacer, il faut aussi réarranger le heap (pas montré dans cet exemple) Remplacer (A,D) 4 avec (C,D) 3 Insert (C,E) 5 Insert (C,F) 11 CSI PCC

17 D Remplacer (A,D) 4 avec (C,D) 3 Insert (C,E) 5 Insert (C,F) 11
 D A B C D E F Mise à jour signifie: enlever les anciennes clés et remplacer par les nouvelles (C,D) 3 (C,D) 3 au lieu de 4 (A,B) 8 (C,E) 5 au lieu de  (C,E) 5 (C,F) 11 au lieu de  Remplacer (A,D) 4 avec (C,D) 3 Insert (C,E) 5 Insert (C,F) 11 CSI PCC

18 D Remplacer (A,D) 4 avec (C,D) 3 Insert (C,E) 5 Insert (C,F) 11
D A B C D E F Mise à jour signifie: enlever les anciennes clés et remplacer par les nouvelles (C,D) 3 (C,D) 3 Instead of 4 (A,B) 8 (C,E) 5 Instead of  (C,E) 5 (C,F) 11 Instead of  (C,F) 11 Remplacer (A,D) 4 avec (C,D) 3 Insert (C,E) 5 Insert (C,F) 11 CSI PCC

19 D RemoveMin() Mis-a-jour C B A E D F 3 2 8 5 4 7 1 9 (C,D) 3 (A,B) 8
D A B C D E F C B A E D F 3 2 8 5 4 7 1 9 (C,D) 3 (A,B) 8 (C,E) 5 (C,F) 11 RemoveMin() Mis-a-jour CSI PCC

20 Mise à jour (D,F) 8 ? Yes 8 < 11
D A B C D E F C B A E D F 3 2 8 5 4 7 1 9 (C,E) 5 (A,B) 8 (C,F) 11 RemoveMin() Mise à jour (D,F) 8 ? Yes 8 < 11 Remplacer (C,F) 11 avec (D,F) 8 CSI PCC

21 Mise à jour (D,F) 8 ? Yes 8 < 11
D A B C D E F C B A E D F 3 2 8 5 4 7 1 9 (C,E) 5 (A,B) 8 (D,F) 8 RemoveMin() Mise à jour (D,F) 8 ? Yes 8 < 11 Remplacer (C,F) 11 avec (D,F) 8 CSI PCC

22 Pourquoi l‘algorithme de Dijkstra fonctionne?
L’algorithme de Dijkstra utilise un algorithme glouton. C’est-à-dire un algorithme qui effectue à chaque étape le choix optimal local dans l’espoir d’arriver à la solution optimale globale. Supposons qu'il n'a pas trouvé toutes les plus courtes distances. Soit F le premier mauvais sommet que l'algorithme a traité. Quand le nœud précédent, D, sur le vrai plus court chemin a été considéré, sa distance était correcte. Mais l’arête (D,F) a été relaxée à ce moment-là! Ainsi, aussi longtemps que d(F)>d(D) la distance de F ne peut pas être fausse. C'est-à-dire, il n'y a pas de mauvais sommet. A 8 4 2 7 2 3 7 1 B C D 3 9 5 8 2 5 E F CSI PCC

23 Le temps d’exécution Si nous représentons G avec une liste d’adjacence, alors nous pouvons parcourir tous les sommets adjacents à u pendant un temps proportionnel à deg(u) La file de priorité Q Avec heap. while Q   do {insérer u dans le nuage C} A chaque itération: - Extraction des sommets avec la distance la plus petite: O(log n). - Mises à jour des clés: O(log n) pour chaque mise à jour (remplacer une clé et insérer dans le tas)=>Apres chaque extraction (deg(u) mises à jour): O(deg(u) log n) En total: uG (1 + deg(u)) log n = O((n+2m) log n) = O(m*log n) Pire cas: O(n2 log n) CSI PCC

24 Le temps d’exécution Avec une séquence non-triée:
O(n) quand on extrait les éléments minimaux mais des mises à jour des clés plus rapides en O(1). Il y a n-1 extractions d’ordre n et m mises à jour d’ordre constant. Le temps d’exécution est O(n2+m) = O(n2 ) En conclusion: Séquence Monceau O(m log n) O(n2 ) CSI PCC