Merge branch 'graphes' into 'master'

Ajout début cours graphes

See merge request !115

10seq01_graphes_cours.md

+---
+jupytext:
+  cell_metadata_filter: -all
+  formats: md:myst
+  text_representation:
+    extension: .md
+    format_name: myst
+    format_version: 0.13
+    jupytext_version: 1.13.8
+kernelspec:
+  display_name: Python 3 (ipykernel)
+  language: python
+  name: python3
+---
+
+# Généralités sur les graphes
+
+## Définitions
+
+:::{prf:definition} Graphe
+* Un graphe orienté est la donnée d'un ensemble de sommets $S$ et d'arcs
+$A$ sous la forme de couples $(s_i, s_j)$, où $s_k$ est élément de $S$.
+* Si, pour toute arcs $(s_i, s_j)$, $A$ contient aussi l'arc $(s_j, s_i)$,
+  on dit que le graphe est non orienté. On parle alors d'arêtes et on les
+  notes sous forme d'ensemble.
+* Si l'ensemble des arcs contient des triplets de la forme $(s_i, s_j, p)$,
+  avec $s_k \in S$ et $p \in ]0 ; +\infty[$, on dit que le graphe est
+  pondéré.
+:::
+
+:::{margin} En mathématiques
+  Les graphes y sont étudiés de façon différentes
+  avec un autre outillage : les matrices.
+:::
+
+::::{prf:example}
+:::{mermaid}
+graph LR
+    A((A)) --> B((B))
+    A --> C((C))
+    B --> D((D))
+    C --> D
+    D --> A
+    D --> C
+:::
+::::
+
+En Python, on note un tel graphe sous la forme d'un dictionnaire, dont les clefs sont les sommets et les valeurs sont la liste des voisins.
+
+::::{prf:example}
+:::{code-block} python
+graphe = {
+  'A': ['B', 'C'],
+  'B': ['D'],
+  'C': ['D'],
+  'D': ['C', 'A']
+}
+:::
+::::
+
+:::{margin} Cas des graphes non orientés
+  On note une arête (par exemple A-B) par l'arc A->B et l'arc B->A.
+:::
+
+:::{margin} Cas des graphes pondérés
+  Dans ce cas, on remplace la liste des voisins par un dictionnaire des pondérations.
+:::
+
+## Représentation avec les matrices
+
+:::{prf:definition} Matrice
+En mathématiques, une matrice est objet algébrique se ramenant à un tableau à $n$ lignes et $p$ colonnes. Si $ n = p$, on dit que la matrice est carrée.
+:::
+
+:::{margin} Matrice en mathématiques
+  Les matrices sont un sujet d'étude très vaste, aussi bien en mathématiques qu'en méthodes numériques.
+:::
+
+:::{prf:definition} Matrice d'adjacence
+La matrice d'adjacence du graphe $G = (\{s_1,...,s_n\}, \{(s_i, s_j), ..., (s_k, s_l)\})$ est un tableau de booléens (ou de nombres pour les graphes pondérés), contenant `True` dans la cellule $(i,j)$ si $(s_i,s_j)$ dans le graphe et `False` sinon.
+:::
+
+::::{prf:example} Matrice d'ajacence de l'exemple
+:::{code-block} python
+M = [
+  [False, True, True, False],
+  [False, False, False, True],
+  [False, False, False, True],
+  [True, False, True, False]
+]
+:::
+::::
+
+:::{prf:remark} Coût de stockage
+:class: "margin"
+Comme la matrice d'adjaence d'un graphe à $n$ sommets est carrée de taille $n^2$, le coût de stockage peut vite devenir important.
+:::

10_graphes_structures.md → 10seq02_graphes_structures.md

@@ -15,22 +15,22 @@ kernelspec:
 
 On va chercher à représenter un graphe, comme structure de données en la
 munissant de l'interface suivante :
-+ une méthode __getVoisins__
-+ une méthode __addArete__
-+ une méthode __getSommet__
++ une méthode __voisins__ qui renvoie les voisins d'un sommet donné
++ une méthode __arete__ qui ajoute un arc entre $e_i$ et $e_j$, les créant si nécessaire.
++ une méthode __sommet__ qui renvoie la liste des sommets.
 
 ```{code-cell} ipython3
 class Graph:
     def __init__(self):
         self.sommetList = dict()
 
-    def getVoisins(self, n):
+    def voisins(self, n):
         if n in self.sommetList:
             return self.sommetList[n]
         else:
             return None
 
-    def addArete(self,o,e):
+    def arete(self,o,e):
         if o not in self.sommetList:
             self.sommetList[o] = {e: 1}
         else:
@@ -38,7 +38,7 @@ class Graph:
         if e not in self.sommetList:
             self.sommetList[e] = {}
 
-    def getSommet(self):
+    def sommet(self):
         return list(self.sommetList.keys())
 
     def __contains__(self,n):
@@ -51,7 +51,7 @@ class Graph:
         return str(self.sommetList)
 
     def __getitem__(self, n):
-        return self.getVoisins(n)
+        return self.voisins(n)
 ```
 
 ```{code-cell} ipython3

10seq03_graphes_parcours.md

+---
+jupytext:
+  cell_metadata_filter: -all
+  formats: md:myst
+  text_representation:
+    extension: .md
+    format_name: myst
+    format_version: 0.13
+    jupytext_version: 1.13.8
+kernelspec:
+  display_name: Python 3 (ipykernel)
+  language: python
+  name: python3
+---
+
+# Parcours dans un graphe
+
+## Parcours en profondeur
+
+```{code-cell} ipython3
+def parcours(g, vus, s):
+    if s not in vus:
+        vus.add(s)
+        for v in g.voisins(s):
+            parcours(g, vus, v)
+```
+
+```{code-cell} ipython3
+def existe_chemin(g, u ,v):
+    vus = set()
+    parcours(g, vus, u)
+    return v in vus
+```
+
+## Détection des cycles
+
+```{code-cell} ipython3
+BLANC, GRIS, NOIR = 1, 2, 3
+
+def parcours_cy(g, couleur, s):
+    if couleur[s] == GRIS:
+        return True
+    if couleur[s] == NOIR:
+        return False
+    couleur[s] = GRIS
+    for v in g.voisins(s):
+        if parcours_cy(g, couleur, v):
+            return True
+    couleur[s] = NOIR
+    return False
+```
+
+```{code-cell} ipython3
+def cycle(g):
+    couleur = {}
+    for s in g.sommets():
+        couleur[s] = BLANC
+    for s in g.sommets():
+        if parcours_cy(g, couleur, s):
+            return True
+    return False
+```
+
+## Parcours en largeur
+
+```{code-cell} ipython3
+def parcours(g, source):
+    dist = {source: 0}
+    courant = {source}
+    suivant = set()
+    while len(courant) > 0:
+        s = courant.pop()
+        for v in g.voisins(s):
+            if v not in dist:
+                suivant.add(v)
+                dist[v] = dist[s] + 1
+        if len(courant) == 0:
+            courant, suivant = suivant, set()
+    return dist
+```
+
+```{code-cell} ipython3
+def distance(g, u, v):
+    dist = parcours_largeur(g, u)
+    return dist[v] if v in dist else None
+```

_toc.yml

@@ -24,7 +24,7 @@ parts:
         sections:
         - file: exemple_somme_recursive
         - file: 1seq03_TD_exemples
-          # - file: 01sesq3_recursif_iteratif
+          # - file: 01seq3_recursif_iteratif
   - caption: Base de données
     chapters:
       - file: 2seq00bdd/2seq1bdd
@@ -59,7 +59,9 @@ parts:
       - file: 09_tables_de_hachages_et_dictionnaire
   - caption: Graphes
     chapters:
-      - file: 10_graphes_structures
+      - file: 10seq01_graphes_cours
+      - file: 10seq02_graphes_structures
+      - file: 10seq03_graphes_parcours
   - caption: Projets
     chapters:
       - file: Projets/CV