From 979a3941f8233ca26ab75afdcb9334e2a093b6b3 Mon Sep 17 00:00:00 2001
From: Orestis <orestis.malaspinas@pm.me>
Date: Tue, 30 May 2023 17:20:05 +0200
Subject: [PATCH] corrected a lot of typos
---
slides/cours_24.md | 92 +++++++++++++++++++++++-----------------------
1 file changed, 46 insertions(+), 46 deletions(-)
diff --git a/slides/cours_24.md b/slides/cours_24.md
index 7e30b5f..4cb0c64 100644
--- a/slides/cours_24.md
+++ b/slides/cours_24.md
@@ -32,7 +32,7 @@ initialiser(graphe) // tous sommets sont non-visités
file = visiter(sommet, vide) // sommet est un sommet
// du graphe
tant que !est_vide(file)
- v = défiler(file)
+ v = defiler(file)
file = visiter(v, file)
file visiter(sommet, file)
@@ -463,7 +463,7 @@ tab dijkstra(graph, s, t)
. . .
* Pour chaque nouveau noeud à visiter, il suffit d'enregistrer d'où on est venu!
-* On a besoin d'un tableau `précédent`.
+* On a besoin d'un tableau `precedent`.
## Modifier le pseudo-code ci-dessus pour ce faire (3min matrix)
@@ -475,7 +475,7 @@ tab dijkstra(graph, s, t)
tab, tab dijkstra(graph, s, t)
pour chaque v dans graphe
distance[v] = infini
- précédent[v] = indéfini
+ precedent[v] = indéfini
q = ajouter(q, v)
distance[s] = 0
tant que non_vide(q)
@@ -489,8 +489,8 @@ tab, tab dijkstra(graph, s, t)
n_distance = distance[u] + w(u, v)
si n_distance < distance[v]
distance[v] = n_distance
- précédent[v] = u
- retourne distance, précédent
+ precedent[v] = u
+ retourne distance, precedent
```
# Algorithme de Dijkstra
@@ -500,14 +500,14 @@ tab, tab dijkstra(graph, s, t)
. . .
```C
-pile parcours(précédent, s, t)
+pile parcours(precedent, s, t)
sommets = vide
u = t
// on a atteint t ou on ne connait pas de chemin
- si u != s && précédent[u] != indéfini
+ si u != s && precedent[u] != indéfini
tant que vrai
sommets = empiler(sommets, u)
- u = précédent[u]
+ u = precedent[u]
si u == s // la source est atteinte
retourne sommets
retourne sommets
@@ -538,11 +538,11 @@ pile parcours(précédent, s, t)
## Trois fonction principales
```C
-booléen est_vide(élément) // triviale
-élément enfiler(élément, data, priorité)
-data défiler(élément)
-rien modifier_priorité(élément, data, priotié)
-nombre priorité(data) // utilitaire
+booléen est_vide(element) // triviale
+element enfiler(element, data, priorite)
+data defiler(element)
+rien changer_priorite(element, data, priorite)
+nombre priorite(element) // utilitaire
```
## Pseudo-implémentation: structure (1min)
@@ -550,10 +550,10 @@ nombre priorité(data) // utilitaire
. . .
```C
-struct élément
+struct element
data
- priorité
- élément suivant
+ priorite
+ element suivant
```
# Les files de priorité
@@ -563,61 +563,61 @@ struct élément
. . .
```C
-élément enfiler(élément, data, priorité)
- n_élément = créer_élément(data, priorité)
- si est_vide(élément)
- retourne n_élément
- si priorité(d) > priorité(e.d)
- n_élément.suivant = élément
- retourne n_élément
+element enfiler(element, data, priorite)
+ n_element = creer_element(data, priorite)
+ si est_vide(element)
+ retourne n_element
+ si priorite(n_element) > priorite(element)
+ n_element.suivant = element
+ retourne n_element
sinon
- tmp = élément
- préc = élément
- tant que !est_vide(tmp) && priorité < tmp.priorité
- préc = tmp
+ tmp = element
+ prec = element
+ tant que !est_vide(tmp) && priorite < priorite(tmp)
+ prec = tmp
tmp = tmp.suivant
- prev.suivant = n_élément
- n_élément.suivant = tmp
- retourne élément
+ prev.suivant = n_element
+ n_element.suivant = tmp
+ retourne element
```
# Les files de priorité
-## Pseudo-implémentation: défiler (2min)
+## Pseudo-implémentation: defiler (2min)
. . .
```C
-data, élément défiler(élément)
- si est_vide(élément)
+data, element defiler(element)
+ si est_vide(element)
retourne AARGL!
sinon
- tmp = élément.data
- n_élément = élément.suivant
- libérer(élément)
- retourne tmp, n_élément
+ tmp = element.data
+ n_element = element.suivant
+ liberer(element)
+ retourne tmp, n_element
```
# Algorithme de Dijkstra avec file de priorité min
```C
-distance, précédent dijkstra(graphe, s, t):
+distance, precedent dijkstra(graphe, s, t):
distance[source] = 0
fp = file_p_vide()
pour v dans sommets(graphe)
si v != s
distance[v] = infini
- précédent[v] = indéfini
+ precedent[v] = indéfini
fp = enfiler(fp, v, distance[v])
tant que !est_vide(fp)
- u, fp = défiler(fp)
+ u, fp = defiler(fp)
pour v dans voisinage de u
n_distance = distance[u] + w(u, v)
si n_distance < distance[v]
distance[v] = n_distance
- précédent[v] = u
- fp = changer_priorité(fp, v, n_distance)
- retourne distance, précédent
+ precedent[v] = u
+ fp = changer_priorite(fp, v, n_distance)
+ retourne distance, precedent
```
# Algorithme de Dijkstra avec file
@@ -633,13 +633,13 @@ O(V) si v != s
O(V) fp = enfiler(fp, v, distance[v]) // notre impl est nulle
------------------O(V * V)-------------------------------
tant que !est_vide(fp)
-O(1) u, fp = défiler(fp)
+O(1) u, fp = defiler(fp)
---------------------------------------------------------
O(E) pour v dans voisinage de u
n_distance = distance[u] + w(u, v)
si n_distance < distance[v]
distance[v] = n_distance
-O(V) fp = changer_priorité(fp, v, n_distance)
+O(V) fp = changer_priorite(fp, v, n_distance)
---------------------------------------------------------
retourne distance
```
@@ -667,7 +667,7 @@ O(V) fp = changer_priorité(fp, v, n_distance)
## A chaque étape donner:
* Le tableau des distances à `a`;
-* Le tableau des prédécessueurs;
+* Le tableau des prédécesseurs;
* L'état de la file de priorité.
# Algorithme de Dijkstra (corrigé)
--
GitLab