added part treated in next class

6f78d6e8 · orestis.malaspin · cf8ed1b1 · 6f78d6e8
Verified Commit 6f78d6e8 authored 3 years ago by orestis.malaspin
--- a/slides/cours_27.md
+++ b/slides/cours_27.md
+---
+title: "Graphes - Arbres couvrants"
+date: "2022-05-03"
+patat:
+    eval:
+        tai:
+            command: fish
+            fragment: false
+            replace: true
+        ccc:
+            command: fish
+            fragment: false
+            replace: true
+    images:
+      backend: auto
+---
+
+# Questions
+
+* A quoi sert l'algorithme de Dijkstra?
+
+. . .
+
+* A trouver le plus court chemin entre un sommet, $s$, d'un graphe pondéré et tous les autres sommets.
+* Quelle est la limitation de l'algorithme de Dijkstra?
+
+. . .
+
+* Les poids doivent être positifs.
+* Résumer les étapes de l'algorithme de Dijkstra.
+
+. . .
+
+* `distance[source] = 0`, `ditance[reste]=inf`;
+* enfiler tous les sommets, `distance <=> priorité`;
+* tant qu'il y a des sommets dans la file:
+    * u = défiler;
+    * pour tous les sommets `v` dans le voisinage de `u`;
+    * mettre à jour `distance[v]` (priorité et précédence) si `distance[v] > distance[u] + w(u,v)`.
+
+
+# Arbres couvrants minimaux
+
+* Comment générer un arbre couvrant minimal?
+
+![Un graphe, connexe, non-orienté, pondéré, et son arbre couvrant minimal.](figs/arbre_couvrant_minimal_exemple.png)
+
+# Algorithme de Prim
+
+::: columns
+
+:::: column
+
+## Un exemple
+
+![Le graphe de départ.](figs/prim_0.png)
+
+::::
+
+:::: column
+
+## On part de `e` (au hasard)
+
+![Le sommet `e` est couvert.](figs/prim_1.png)
+
+::::
+
+:::
+
+# Algorithme de Prim
+
+::: columns
+
+:::: column
+
+## On choisit comment? 
+
+![Quelle arête choisir?](figs/prim_1.png)
+
+. . .
+
+* L'arête la plus courte sortant d'un sommet déjà visité, et entrant dans un sommet non-visité.
+
+::::
+
+:::: column
+
+. . .
+
+## L'arête `e->d`
+
+![Le sommet `d` est couvert.](figs/prim_2.png)
+
+::::
+
+:::
+
+# Algorithme de Prim
+
+::: columns
+
+:::: column
+
+## On choisit comment? 
+
+![Quelle arête choisir?](figs/prim_2.png)
+
+. . .
+
+* L'arête la plus courte sortant d'un sommet déjà visité, et entrant dans un sommet non-visité.
+
+::::
+
+:::: column
+
+. . .
+
+## L'arête `d->a`
+
+![Le sommet `a` est couvert.](figs/prim_3.png)
+
+::::
+
+:::
+
+# Algorithme de Prim
+
+::: columns
+
+:::: column
+
+## On choisit comment? 
+
+![Quelle arête choisir?](figs/prim_3.png)
+
+. . .
+
+* L'arête la plus courte sortant d'un sommet déjà visité, et entrant dans un sommet non-visité.
+
+::::
+
+:::: column
+
+. . .
+
+## L'arête `d->c`
+
+![Le sommet `c` est couvert.](figs/prim_4.png)
+
+::::
+
+:::
+
+# Algorithme de Prim
+
+::: columns
+
+:::: column
+
+## On choisit comment? 
+
+![Quelle arête choisir?](figs/prim_4.png)
+
+. . .
+
+* L'arête la plus courte sortant d'un sommet déjà visité, et entrant dans un sommet non-visité.
+
+::::
+
+:::: column
+
+. . .
+
+## L'arête `e->b`
+
+![Le sommet `b` est couvert.](figs/prim_5.png)
+
+::::
+
+:::
+
+* Game over!
+
+# Algorithme de Prim
+
+## Structures de données
+
+* Dans quoi allons nous stocker les sommets?
+
+. . .
+
+* File de priorité min.
+* Autre chose?
+
+. . .
+
+* Tableau des distances (comme pour Dijkstra).
+* Autre chose?
+
+. . .
+
+* Tableau des parents (presque comme pour Dijkstra).
+* Autre chose?
+
+. . .
+
+* Non.
+
+# Algorithme de Prim
+
+## Initialisation: Pseudo-code (2min)
+
+. . .
+
+```C
+file_priorité, distance, parent initalisation(graphe)
+    r = aléatoire(graphe)
+    distance[r] = 0
+    parent[r] = 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])
+    retourne fp, distance, parent
+```
+
+# Algorithme de Prim
+
+## Algorithme: Pseudo-code (5min)
+
+. . .
+
+```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))
+    retourne sommets, parent
+```
+
+# Exemple d'algorithme de Prim
+
+::: columns
+
+:::: {.column width="40%"}
+
+## Un exemple
+
+![Étape 1.](figs/prim_1.png)
+
+::::
+
+:::: column
+
+```
+FP |  e  |  d  |  b  |  c  |  a  |
+----------------------------------
+D  |  0  | inf | inf | inf | inf |
+
+   |  e  |  d  |  b  |  c  |  a  |
+----------------------------------
+P  |  -  |  -  |  -  |  -  |  -  |
+```
+
+## Devient?
+
+. . .
+
+```
+FP |  d  |  b  |  c  |  a  |
+----------------------------
+D  |  4  |  5  |  5  | inf |
+
+   |  e  |  d  |  b  |  c  |  a  |
+----------------------------------
+P  |  -  |  e  |  e  |  e  |  -  |
+```
+
+::::
+
+:::
+
+# Exemple d'algorithme de Prim
+
+::: columns
+
+:::: {.column width="40%"}
+
+## Un exemple
+
+![Étape 2.](figs/prim_2.png)
+
+::::
+
+:::: column
+
+```
+FP |  d  |  b  |  c  |  a  |
+----------------------------
+D  |  4  |  5  |  5  | inf |
+
+   |  e  |  d  |  b  |  c  |  a  |
+----------------------------------
+P  |  -  |  e  |  e  |  e  |  -  |
+```
+
+## Devient?
+
+. . .
+
+```
+FP |  a  |  c  |  b  |
+----------------------
+D  |  2  |  4  |  5  |
+
+   |  e  |  d  |  b  |  c  |  a  |
+----------------------------------
+P  |  -  |  e  |  e  |  d  |  d  |
+```
+
+::::
+
+:::
+
+# Exemple d'algorithme de Prim
+
+::: columns
+
+:::: {.column width="40%"}
+
+## Un exemple
+
+![Étape 3.](figs/prim_3.png)
+
+::::
+
+:::: column
+
+```
+FP |  a  |  c  |  b  |
+----------------------
+D  |  2  |  4  |  5  |
+
+   |  e  |  d  |  b  |  c  |  a  |
+----------------------------------
+P  |  -  |  e  |  e  |  d  |  d  |
+```
+
+## Devient?
+
+. . .
+
+```
+FP |  c  |  b  |
+----------------
+D  |  4  |  5  |
+
+   |  e  |  d  |  b  |  c  |  a  |
+----------------------------------
+P  |  -  |  e  |  e  |  d  |  d  |
+```
+
+::::
+
+:::
+
+# Exemple d'algorithme de Prim
+
+::: columns
+
+:::: {.column width="40%"}
+
+## Un exemple
+
+![Étape 4.](figs/prim_4.png)
+
+::::
+
+:::: column
+
+```
+FP |  c  |  b  |
+----------------
+D  |  4  |  5  |
+
+   |  e  |  d  |  b  |  c  |  a  |
+----------------------------------
+P  |  -  |  e  |  e  |  d  |  d  |
+```
+
+## Devient?
+
+. . .
+
+```
+FP |  b  |
+----------
+D  |  5  |
+
+   |  e  |  d  |  b  |  c  |  a  |
+----------------------------------
+P  |  -  |  e  |  e  |  d  |  d  |
+```
+
+::::
+
+:::
+
+# Exemple d'algorithme de Prim
+
+::: columns
+
+:::: {.column width="40%"}
+
+## Un exemple
+
+![Étape 5.](figs/prim_4.png)
+
+::::
+
+:::: column
+
+```
+FP |  b  |
+----------
+D  |  5  |
+
+   |  e  |  d  |  b  |  c  |  a  |
+----------------------------------
+P  |  -  |  e  |  e  |  d  |  d  |
+```
+
+## Devient?
+
+. . .
+
+```
+FP |
+----
+D  |
+
+   |  e  |  d  |  b  |  c  |  a  |
+----------------------------------
+P  |  -  |  e  |  e  |  d  |  d  |
+```
+
+::::
+
+:::
+
+# Exercice: algorithme de Prim
+
+## Appliquer l'algorithme de Prim à (15min):
+
+![En démarrant du sommet $V_1$.](figs/prim_exercice.png)
+
+# Exercice: algorithme de Prim
+
+## Solution
+
+![](figs/prim_solution.png)
+
+# Complexité de l'algorithme de Prim
+
+\footnotesize
+
+```C
+file_priorité, distance, parent initalisation(graphe)
+    // choix r et initialisation
+    pour v dans sommets(graphe)
+O(|V|)  // initialisation distance et parent
+        fp = enfiler(fp, v, distance[v])
+    retourne fp, distance, parent
+sommets, parent prim(file_priorité, distance, parent)
+    sommets = vide
+    tant que !est_vide(file_priorité)
+O(|V|)  u, fp = défiler(file_priorité)
+        sommets = insérer(sommets, u)
+        pour v dans voisinage de u et pas dans sommets
+    O(|E|)  si w(u, v) < distance[v]
+                // màj dista + parent
+        O(|V|)  fp = changer_priorité(fp, w, w(u, v))
+    retourne sommets, parent
+```
+
+* $O(|V|)+O(|E|)+O(|V|^2)=O(|E|+|V|^2)$
+* Remarque: $O(|E|)$ n'est pas mutliplié par $O(|V|)$, car les arêtes parcourues qu'une fois en **tout**.
+
+# Algorithme de Kruskal
+