From cf8fdbab743de929f2ff132703b5dca650b695c7 Mon Sep 17 00:00:00 2001
From: Orestis <orestis.malaspinas@pm.me>
Date: Thu, 11 Nov 2021 14:27:13 +0100
Subject: [PATCH] =?UTF-8?q?mise=20=C3=A0=20jour=20du=20board?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
slides/cours_7.md | 116 -------------------------
slides/cours_8.md | 213 ++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 213 insertions(+), 116 deletions(-)
create mode 100644 slides/cours_8.md
diff --git a/slides/cours_7.md b/slides/cours_7.md
index 9d012b9..f9565d5 100644
--- a/slides/cours_7.md
+++ b/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é.
-
-](./figs/fig_recursivite_8_reines.png){width=35%}
-
-# Problème des 2-reines
-
-{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
-
-
-
-# Problème des 4-reines
-
-
-
-# Problème des 4-reines, symétrie
-
-
-
-# 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.
-
-
-
diff --git a/slides/cours_8.md b/slides/cours_8.md
new file mode 100644
index 0000000..0415fe5
--- /dev/null
+++ b/slides/cours_8.md
@@ -0,0 +1,213 @@
+---
+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é.
+
+](./figs/fig_recursivite_8_reines.png){width=35%}
+
+# Problème des 2-reines
+
+{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
+
+
+
+# Problème des 4-reines
+
+
+
+# Problème des 4-reines, symétrie
+
+
+
+# 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
+```
+
--
GitLab