doing file dijkstra

slides/cours_25.md

@@ -378,4 +378,111 @@ pile parcours(précédent, s, t)
 
 ::::
 
-:::
\ No newline at end of file
+:::
+
+# 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
+
+* Avec une file de priorité!
+
+## Une file de priorité est
+
+* Une file dont chaque élément possède une priorité,
+* Elle existe en deux saveurs: `min` ou `max`:
+    * File `min`: les éléments les plus petits sont retirés en premier.
+    * File `max`: les éléments les plus grands sont retirés en premier.
+* On s'intéresse à la `max`.
+
+## Comment on fait ça?
+
+. . .
+
+* On insère les éléments à haute priorité tout devant dans la file!
+
+# Les files de priorité
+
+## Trois fonction principales
+
+```C
+booléen est_vide(élément) // triviale
+élément enfiler(élément, data)
+data défiler(élément)
+nombre priorité(data) // utilitaire
+```
+
+## Pseudo-implémentation: structure (1min)
+
+. . .
+
+```C
+struct élément
+    data d
+    élément next
+```
+
+# Les files de priorité
+
+## Pseudo-implémentation: enfiler (2min)
+
+. . .
+
+```C
+élément enfiler(élément e, d)
+    élément = créer_élément(d)
+    si est_vide(e)
+        retourne élément
+    si priorité(d) > priorité(e.d)
+        élément.next = e
+        retourne e
+    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           
+```
+
+# Les files de priorité
+
+## Pseudo-implémentation: défiler (2min)
+
+. . .
+
+```C
+data défiler(élément e)
+    si est_vide(e)
+        retourne AARGL!
+    sinon
+        retourne e.d
+```
+
+# Algorithme de Dijkstra avec file
+
+
+function Dijkstra(graphe, s, t):
+    distance[source] = 0
+    fp = file_p_vide()
+    pour chaque 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