maj cours

slides/cours_27.md

@@ -5,6 +5,8 @@ date: "2024-06-04"
 
 # Rappel (1/2)
 
+\footnotesize
+
 ## Algorithme de Dijkstra: à quoi sert-il?
 
 . . .
@@ -17,11 +19,11 @@ A trouver le plus court chemin entre deux sommets d'un graphe!
 
 ```C
 distance[source] = 0
-distance[reste]  = inf;
+distance[reste]  = inf
 pour sommet dans liste_sommets:
     fp = enfiler(fp, sommet, w(source, sommet)) // file min
 tant !est_vide(fp):
-    sommet_courant, fp = défiler(fp);
+    sommet_courant, fp = défiler(fp)
     pour sommet_voisin dans voisinage(sommet_courant):
         n_dist = distance[sommet_courant] + w(sommet_courant, sommet_voisin)
         si distance[sommet_voisin] > n_dist:
@@ -305,20 +307,22 @@ matrice, matrice floyd_warshall(distance, n, w)
 
 ```C
 file_priorité, distance, parent initialisation(graphe)
-    r = aléatoire(graphe)
-    distance[r] = 0
-    parent[r] = indéfini
+    s_initial = aléatoire(graphe)
+    distance[s_initial] = 0
+    parent[s_initial] = indéfini
     fp = file_p_vide()
-    pour v dans sommets(graphe)
-        si v != r
-            distance[v] = infini
-            parent[v]   = indéfini
-        fp = enfiler(fp, v, distance[v])
+    pour s_courant dans sommets(graphe)
+        si s_courant != s_initial
+            distance[s_courant] = infini
+            parent[s_courant]   = indéfini
+        fp = enfiler(fp, s_courant, distance[s_courant])
     retourne fp, distance, parent
 ```
 
 # Algorithme de Prim
 
+\footnotesize
+
 ## Algorithme: Pseudo-code (5min)
 
 . . .
@@ -326,15 +330,16 @@ file_priorité, distance, parent initialisation(graphe)
 ```C
 sommets, parent prim(file_priorité, distance, parent)
     sommets = vide
-    tant que !est_vide(file_priorité)
-        u, fp = défiler(file_priorité)
-        sommets = insérer(sommets, u)
-        pour v dans voisinage de u et pas dans sommets 
-        // ou dans file_priorité
-            si w(u, v) < distance[v]
-                parent[w] = u
-                distance[w] = w(u, v)
-                fp = changer_priorité(fp, w, w(u, v))
+    tant que !est_vide(fp)
+        s_courant, fp = défiler(fp)
+        sommets = insérer(sommets, s_courant)
+        pour s_voinsin dans voisinage(s_courant) et pas dans sommets 
+        // ou dans fp
+            si poids(s_courant, s_voinsin) < distance[s_voinsin]
+                parent[s_voinsin] = s_courant
+                distance[s_voinsin] = poids(s_courant, s_voinsin)
+                fp = changer_priorité(fp, 
+                    s_voinsin, poids(s_courant, s_voinsin))
     retourne sommets, parent
 ```
 
@@ -734,7 +739,7 @@ O(|V|)  u, fp = défiler(file_priorité)
     * Retirer $(u,v)$ de $E$,
     * Si $u\in V_i$ et $v\in V_j$ avec $V_i\cap V_j=\emptyset$:
         * Ajouter $(u,v)$ à $A$;
-        * Fusionner $U$ et $V$ dans $F$.
+        * Fusionner $u$ et $v$ dans $F$.
 
 # Algorithme de Kruskal: exemple