added details

slides/cours_25.md

@@ -380,12 +380,6 @@ pile parcours(précédent, s, t)
 
 :::
 
-# Algorithme de Dijkstra (exercice)
-
-## Trouver le chemin de `a` à tous lesautres sommets
-
-![L'exercice.](figs/dijkstra_exo.png)
-
 # Algorithme de Dijkstra amélioré
 
 ## On peut améliorer l'algorithme
@@ -412,8 +406,9 @@ pile parcours(précédent, s, t)
 
 ```C
 booléen est_vide(élément) // triviale
-élément enfiler(élément, data)
+élément enfiler(élément, data, priorité)
 data défiler(élément)
+rien modifiier_priorité(élément, data, priotié)
 nombre priorité(data) // utilitaire
 ```
 
@@ -423,8 +418,9 @@ nombre priorité(data) // utilitaire
 
 ```C
 struct élément
-    data d
-    élément next
+    data
+    priorité
+    élément suivant
 ```
 
 # Les files de priorité
@@ -434,22 +430,22 @@ struct élément
 . . .
 
 ```C
-élément enfiler(élément e, d)
-    élément = créer_élément(d)
-    si est_vide(e)
-        retourne élément
+élément enfiler(élément, data, priorité)
+    n_élément = créer_élément(data, priorité)
+    si est_vide(élément)
+        retourne n_élément
     si priorité(d) > priorité(e.d)
-        élément.next = e
-        retourne e
+        n_élément.suivant = élément
+        retourne n_élément
     sinon
-        tmp = e
-        prev = e
-        tant que !est_vide(tmp) && priorité(d) < priorité(tmp.d)
-            prev = tmp
-            tmp = tmp.next
-        prev.next = élément
-        élément.next = tmp
-        retourne e           
+        tmp = élément
+        préc = élément
+        tant que !est_vide(tmp) && priorité < tmp.priorité
+            préc = tmp
+            tmp = tmp.suivant
+        prev.suivant = n_élément
+        n_élément.suivant = tmp
+        retourne élément           
 ```
 
 # Les files de priorité
@@ -459,30 +455,99 @@ struct élément
 . . .
 
 ```C
-data défiler(élément e)
-    si est_vide(e)
+data, élément défiler(élément)
+    si est_vide(élément)
         retourne AARGL!
     sinon
-        retourne e.d
+        tmp = élément.data
+        n_élément = élément.suivant
+        libérer(élément)
+        retourne tmp, n_élément
 ```
 
 # Algorithme de Dijkstra avec file
 
+```C
+distance, précédent dijkstra(graphe, s, t):
+    distance[source] = 0
+    fp = file_p_vide()
+    pour v dans sommets(graphe)
+        si v != s
+            distance[v] = infini
+            précédent[v] = indéfini
+        fp = enfiler(fp, v, distance[v])
+    tant que !est_vide(fp)
+        u, fp = défiler(fp)
+        pour v dans voisinage de u
+            n_distance = distance[u] + w(i, v)
+            si n_distance < distance[v]
+                distance[v] = n_distance
+                précédent[v] = u
+                fp = changer_priorité(fp, v, n_distance)
+    retourne distance, précédent
+```
+
+# Algorithme de Dijkstra (exercice, 5min) 
+
+![L'exercice.](figs/dijkstra_exo.png)
+
+* Donner la liste de priorité, puis...
+
+## A chaque étape donner:
 
-function Dijkstra(graphe, s, t):
+* Le tableau des distances à `a`;
+* Le tableau des prédécessueurs;
+* L'état de la file de priorité.
+
+# Algorithme de Dijkstra (corrigé) 
+
+![Le corrigé partie 1.](figs/dijkstra_ex_0.png)
+
+# Algorithme de Dijkstra (corrigé) 
+
+![Le corrigé partie 2.](figs/dijkstra_ex_1.png)
+
+# Algorithme de Dijkstra (corrigé) 
+
+![Le corrigé partie 3.](figs/dijkstra_ex_2.png)
+
+# Algorithme de Dijkstra (corrigé) 
+
+![Le corrigé partie 4.](figs/dijkstra_ex_3.png)
+
+# Algorithme de Dijkstra (corrigé) 
+
+![Le corrigé partie 5.](figs/dijkstra_ex_4.png)
+
+# Algorithme de Dijkstra (corrigé) 
+
+![Le corrigé partie 6.](figs/dijkstra_ex_5.png)
+
+# Complexité de l'algorithme de Dijkstra?
+
+\footnotesize
+
+. . .
+
+```C
+distance, précédent dijkstra(graphe, s, t):
     distance[source] = 0
     fp = file_p_vide()
-    pour chaque v dans sommets(graphe)
+----------------------------------------------
+    pour v dans sommets(graphe)
         si v != s
-            distance[v] = infinit
-        fp = enfiler(fq, v)
-    
-    while Q is not empty:                      // The main loop
-        u ← Q.extract_min()                    // Remove and return best vertex
-        for each neighbor v of u:              // only v that are still in Q
-            alt ← dist[u] + Graph.Edges(u, v)
-            if alt < dist[v]
-                dist[v] ← alt
-                prev[v] ← u
-                Q.decrease_priority(v, alt)
-    return dist, prev
+O(V)        distance[v] = infini
+        fp = enfiler(fp, v, distance[v])
+----------------------------------------------
+    tant que !est_vide(fp)
+O(V)    u, fp = défiler(fp)
+    ----------------------------------------------
+        pour v dans voisinage de u
+    O(E)    n_distance = distance[u] + w(i, v)
+            si n_distance < distance[v]
+                distance[v] = n_distance
+                fp = changer_priorité(fp, v, n_distance)
+    ----------------------------------------------
+----------------------------------------------
+    retourne distance
+```