mise à jour du board

slides/cours_7.md

@@ -347,120 +347,4 @@ $$
 
 ```
 
-# L'algorithme du PPCM *récursif* (1/3)
-
-## Exemple d'algorithme pour le calcul
-
-```C
-PPCM(36, 90):
-36  < 90  // 36  + 36
-72  < 90  // 72  + 36
-108 > 90  // 90  + 90
-108 < 180 // 108 + 36
-144 < 180 // 144 + 36
-180 = 180 // The End!
-```
-
-. . .
-
-* On incrémente de 36 à gauche et de 90 à droite jusqu'à ce que les deux
-  soient égaux.
-
-
-# L'algorithme du PPCM *récursif* (2/3)
-
-## Rappel de l'algorithme
-
-```C
-// on cherche i*m == j*m (i,j aussi petits que possibles)
-int ppcm(int m, int n) { 
-    int mult_m = m, mult_n = n;
-    while (mult_m != mult_n) {
-        if (mult_m > mult_n) {
-            mult_n += n;
-        } else {
-            mult_m += m;
-        }
-    }
-    return mult_m;
-}
-```
-
-. . .
-
-## Écrire l'algorithme *récursif* du PPCM (matrix)
-
-
-# L'algorithme du PPCM *récursif* (3/3)
-
-## Pseudo-code
-
--   Algorithme du PPCM de deux nombres `n` et `m`
-    -   `ppcm(mult_n,mult_m) = ppcm(mult_n + n, mult_m)`    
-        si `mult_n < mult_m`   (récursivité)
-    -   `ppcm(mult_n,mult_m) = ppcm(mult_n, mult_m + m)`    
-        si `mult_n > mult_m`   (récursivité)
-    -   `ppcm(mult_n,mult_m) = mult_n`      
-        si `mult_n = mult_m`   (condition d’arrêt)
-
-# Problème des 8-reines
-
-* Placer 8 reines sur un échiquier de $8 \times 8$.
-* Sans que les reines ne puissent se menacer mutuellement (92 solutions). 
-
-## Conséquence
-
-* Deux reines ne partagent pas la même rangée, colonne, ou diagonale.
-* Donc chaque solution a **une** reine **par colonne** ou **ligne**.
-
-## Généralisation
-
-* Placer $N$ reines sur un échiquier de $N \times
-  N$. 
-- Exemple de **backtracking** (retour en arrière) $\Rightarrow$ récursivité.
-
-![Problème des 8-reines. Source:
-[wikipedia](https://fr.wikipedia.org/wiki/Problème_des_huit_dames)](./figs/fig_recursivite_8_reines.png){width=35%}
-
-# Problème des 2-reines
-
-![Le problème des 2 reines n'a pas de solution.](figs/2reines.svg){width=50%}
-
-# Comment trouver les solutions?
-
-* On pose la première reine sur la première case disponible.
-* On rend inaccessibles toutes les cases menacées.
-* On pose la reine suivante sur la prochaine case non-menacée.
-* Jusqu'à ce qu'on puisse plus poser de reine.
-* On revient alors en arrière jusqu'au dernier coup où il y avait plus qu'une
-  possibilité de poser une reine.
-* On recommence depuis là.
-
-. . .
-
-* Le jeu prend fin quand on a énuméré *toutes* les possibilités de poser les
-  reines.
-
-# Problème des 3-reines
-
-![Le problème des 3 reines n'a pas de solution non plus.](figs/3reines.svg)
-
-# Problème des 4-reines
-
-![Le problème des 4 reines a une solution.](figs/4reines.svg)
-
-# Problème des 4-reines, symétrie
-
-![Le problème des 4 reines a une autre solution (symétrie
-horizontale).](figs/4reines_sym.svg)
-
-# Problème des 5 reines
-
-## Exercice: Trouver une solution au problème des 5 reines
-
-* Faire une capture d'écran / une photo de votre solution et la poster sur
-  matrix.
-
-
-
 

slides/cours_8.md

+---
+title: "Backtracking et piles"
+date: "2021-11-17"
+patat:
+  eval:
+    tai:
+      command: fish
+      fragment: false
+      replace: true
+    ccc:
+      command: fish
+      fragment: false
+      replace: true
+  images:
+    backend: auto
+...
+
+
+# L'algorithme du PPCM *récursif* (1/3)
+
+## Exemple d'algorithme pour le calcul
+
+```C
+PPCM(36, 90):
+36  < 90  // 36  + 36
+72  < 90  // 72  + 36
+108 > 90  // 90  + 90
+108 < 180 // 108 + 36
+144 < 180 // 144 + 36
+180 = 180 // The End!
+```
+
+. . .
+
+* On incrémente de 36 à gauche et de 90 à droite jusqu'à ce que les deux
+  soient égaux.
+
+
+# L'algorithme du PPCM *récursif* (2/3)
+
+## Rappel de l'algorithme
+
+```C
+// on cherche i*m == j*m (i,j aussi petits que possibles)
+int ppcm(int m, int n) { 
+    int mult_m = m, mult_n = n;
+    while (mult_m != mult_n) {
+        if (mult_m > mult_n) {
+            mult_n += n;
+        } else {
+            mult_m += m;
+        }
+    }
+    return mult_m;
+}
+```
+
+. . .
+
+## Écrire l'algorithme *récursif* du PPCM (matrix)
+
+
+# L'algorithme du PPCM *récursif* (3/3)
+
+## Pseudo-code
+
+-   Algorithme du PPCM de deux nombres `n` et `m`
+    -   `ppcm(mult_n,mult_m) = ppcm(mult_n + n, mult_m)`    
+        si `mult_n < mult_m`   (récursivité)
+    -   `ppcm(mult_n,mult_m) = ppcm(mult_n, mult_m + m)`    
+        si `mult_n > mult_m`   (récursivité)
+    -   `ppcm(mult_n,mult_m) = mult_n`      
+        si `mult_n = mult_m`   (condition d’arrêt)
+
+# Problème des 8-reines
+
+* Placer 8 reines sur un échiquier de $8 \times 8$.
+* Sans que les reines ne puissent se menacer mutuellement (92 solutions). 
+
+## Conséquence
+
+* Deux reines ne partagent pas la même rangée, colonne, ou diagonale.
+* Donc chaque solution a **une** reine **par colonne** ou **ligne**.
+
+## Généralisation
+
+* Placer $N$ reines sur un échiquier de $N \times
+  N$. 
+- Exemple de **backtracking** (retour en arrière) $\Rightarrow$ récursivité.
+
+![Problème des 8-reines. Source:
+[wikipedia](https://fr.wikipedia.org/wiki/Problème_des_huit_dames)](./figs/fig_recursivite_8_reines.png){width=35%}
+
+# Problème des 2-reines
+
+![Le problème des 2 reines n'a pas de solution.](figs/2reines.svg){width=50%}
+
+# Comment trouver les solutions?
+
+* On pose la première reine sur la première case disponible.
+* On rend inaccessibles toutes les cases menacées.
+* On pose la reine suivante sur la prochaine case non-menacée.
+* Jusqu'à ce qu'on puisse plus poser de reine.
+* On revient alors en arrière jusqu'au dernier coup où il y avait plus qu'une
+  possibilité de poser une reine.
+* On recommence depuis là.
+
+. . .
+
+* Le jeu prend fin quand on a énuméré *toutes* les possibilités de poser les
+  reines.
+
+# Problème des 3-reines
+
+![Le problème des 3 reines n'a pas de solution non plus.](figs/3reines.svg)
+
+# Problème des 4-reines
+
+![Le problème des 4 reines a une solution.](figs/4reines.svg)
+
+# Problème des 4-reines, symétrie
+
+![Le problème des 4 reines a une autre solution (symétrie
+horizontale).](figs/4reines_sym.svg)
+
+# Problème des 5 reines
+
+## Exercice: Trouver une solution au problème des 5 reines
+
+* Faire une capture d'écran / une photo de votre solution et la poster sur
+  matrix.
+
+```C
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+# Quelques observations sur le problème
+
+* Une reine par colonne au plus.
+* On place les reines sur des colonnes successives.
+* On a pas besoin de "regarder en arrière" (on place "devant" uniquement).
+* Trois étapes:
+    * On place une reine dans une case libre.
+    * On met à jour le tableau.
+    * Quand on a plus de cases libres on "revient dans le temps" ou c'est qu'on
+      a réussi.
+
+# Le code du problème des 8 reines (1/N)
+
+## Quelle structure de données?
+
+. . .
+
+Une matrice de booléens fera l'affaire:
+
+```C
+bool board[n][n];
+```
+
+## Quelles fonctionalités?
+
+. . .
+
+```C
+// Pour chaque ligne placer la reine sur toutes les colonnes
+// Et compter les solutions
+void nb_sol(board, co, count);
+// Placer la reine à li, co et rendre inaccessible devant
+void placer_devant(board_ini, board, li, co);
+```
+
+# Le code du problème des 8 reines (1/N)
+
+## Le calcul du nombre de solutions
+
+```C
+// Calcule le nombre de solutions au problème des <n> reines
+nbr_solutions(board, colonne, compteur)
+    // pour chaque ligne 
+        // si la case libre
+            // si la colonne < n - 1
+                // poser une reine et mettre à jour le tableau
+                // nbr_solutions(board, colonne, compteur)
+            // sinon
+                // on a posé la n-ème et on a gagné
+                // compteur += 1
+```
+
+# Le code du problème des 8 reines (2/N)
+
+## Le calcul du nombre de solutions
+
+```C
+// Calcule le nombre de solutions au problème des <n> reines
+placer_devant(old_board, board, ligne, colonne)
+    // board = copy(board); 
+    // board est occupé à ligne/colonne
+        // toutes les cases des colonnes
+        // suivantes sont mises à jour
+```
+