{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Annexe optionnelle — Dijkstra avec une structure de données en dictionnaire\n",
    "\n",
    "### 2ème mise en œuvre de l'algorithme de Dijkstra\n",
    "VERSION corrigée\n",
    "\n",
    "> **Cette annexe est facultative**, pour les étudiantes à l'aise en Python qui veulent aller plus loin après la Séance 7. Elle reprend le même algorithme que la Séance 7, mais avec une structure de données en dictionnaire plutôt qu'en liste — un bon exercice de transfert, mais pas un prérequis pour la suite du cours."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conditions de réalisation de l'évaluation:\n",
    "- Travail en binome.\n",
    "- A rendre dans un délai de 15 jours après la séance.\n",
    "- soit en complétant le notebook fourni soit sous la forme d'un fichier exécutable .py."
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1- Présentation\n",
    " Lors de l'activité précédente vous avez abouti à l'implémentation de l'algorithme de Dijkstra en vous appuyant sur une structure de données sous forme de liste.\n",
    "Le graphe :\n",
    "![image.png](attachment:image.png)\n",
    "Cette fois ci je vous demande de construire une solution dans laquelle le graphe serait représenté sous la forme d'un dictionnaire dans lequel les clés serait les sommets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2- Représentation du graphe par un dictionnaire\n",
    " ### Travail 1 : définir la structure de donnée\n",
    "Définir la structure de donnée pour représenter le graphe sous forme d’un dictionnaire. \n",
    " L'idée est de créer un dictionnaire dans lequel chaque sommet serait une clé. Et pour chaque clé on aurait à nouveau un dictionnaire contenant les sommets adjacents et la distance depuis le sommet précédent.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#création du dictionnaire du graphe pondéré pour la recherche du plus court chemin\n",
    "graph = {\n",
    "'A': {'B': 4, 'C': 2},\n",
    "'B': {'A': 4, 'C': 6, 'E':5},\n",
    "'C': {'A': 2, 'B': 6, 'D': 3, 'H' : 5},\n",
    "'D': {'C': 3, 'H': 1, 'G': 4, 'F': 3},\n",
    "'E': {'B': 5, 'F': 2},\n",
    "'F': {'E': 2, 'D': 3, 'G': 7},\n",
    "'G': {'F': 7, 'D': 4, 'H': 10},\n",
    "'H': {'C': 5, 'D': 1, 'G': 10},\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous avez la possibilité de revenir vers l’enseignant pour valider votre solution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3- Implémentation de l'algorithme de Dijkstra\n",
    " ### Travail 2 : implémenter votre solution\n",
    " Votre solution sera documentée et s'appuiera sur le travail réalisé en classe.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialisation(s_debut):\n",
    "    \"\"\"\n",
    "    initialisation des variables permettant de parcourir le graphe\n",
    "    Parameters\n",
    "    ----------\n",
    "    depart : string\n",
    "        sommet de depart pour le parcours du graphe.\n",
    "    Returns\n",
    "    -------\n",
    "    E_calcul : dict\n",
    "        chemin en cours de calcul: poids et sommet précédent\n",
    "        E_calcul = {s_debut:[poids,prédécesseur]}\n",
    "        la distance au sommet de depart est nulle\n",
    "    E_sommets : dict\n",
    "        on met dans le dictionnaire provisoire les sommets adjacents \n",
    "        et leur poids par rapport au point de départ\n",
    "        E_sommets = {s_voisin1: [poids,depart],...}\n",
    "    \"\"\"\n",
    "    assert type(s_debut) == str, \" s_debut doit être un caractère \"\n",
    "    \n",
    "    E_calcul = dict()\n",
    "    E_calcul = {s_debut:[0,s_debut]}\n",
    "    \n",
    "    E_sommets=dict()\n",
    "    for suivant in graph[s_debut]:\n",
    "        #chemins en cours d'exploration : sommet: poids, précédent\n",
    "        E_sommets[suivant]=[graph[s_debut][suivant],s_debut]\n",
    "\n",
    "    return E_calcul,E_sommets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Maj_poids(s_voisin,s_mini,poids, E_sommets):\n",
    "    \"\"\"\n",
    "    Mise à jour du poids et du prédécesseur\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    s_voisin : str\n",
    "        sommet voisin\n",
    "    s_mini : str\n",
    "        sommet de poids mini\n",
    "    poids : int\n",
    "        poids du chemin le plus court \n",
    "    E_sommets : dict\n",
    "        dictionnaire des chemins en cours d'exploration'\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    E_sommets : dict\n",
    "        dictionnaire des chemins en cours d'exploration mise à jour\n",
    "        avec le poids et le sommet de poids mini\n",
    "\n",
    "    \"\"\"\n",
    "    #si le sommet est nouveau\n",
    "    #mettre àjour poids et prédecesseur\n",
    "    if s_voisin in E_sommets: \n",
    "        d=poids + graph[s_mini][s_voisin]\n",
    "        if d< E_sommets[s_voisin][0]:\n",
    "            #mémoriser son prédécesseur et le poids depuis le début\n",
    "            E_sommets[s_voisin] = [d,s_mini]\n",
    "    else:\n",
    "        #si le sommet est déjà découvert mettre à jour le poids\n",
    "        E_sommets[s_voisin]=[poids + graph[s_mini][s_voisin],s_mini]\n",
    "    return E_sommets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Dijkstra(graphe, s_debut):\n",
    "    \"\"\"\n",
    "    Cette fonction implémente l'algorithme de dijkstra\n",
    "    Parameters\n",
    "    ----------\n",
    "    graphe : dict\n",
    "        DESCRIPTION. description du graphe\n",
    "    s_debut : str\n",
    "        DESCRIPTION. le sommet de départ\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    calcul: dict\n",
    "        le résultat de l'algorithme de dijkstra\n",
    "\n",
    "    \"\"\"\n",
    "    assert type(s_debut) == str, \" s_debut doit être un caractère \"\n",
    "    assert type(graphe)   == dict, \"graphe doit être un dictionnaire\"\n",
    "    \n",
    "    \n",
    "    #phase d'initialisation des données\n",
    "    E_calcul,E_sommets=initialisation(s_debut)\n",
    "    \n",
    "    #tant que provisoire non vide\n",
    "    while E_sommets!= {}:                                      \n",
    "        #recherche de la distance la plus faible\n",
    "        s_mini=min(E_sommets, key=E_sommets.get)                   \n",
    "        #ajout du sommet de valeur minimum aux sommets explorés\n",
    "        E_calcul[s_mini]=E_sommets[s_mini]\n",
    "        poids = E_sommets[s_mini][0]\n",
    "        \n",
    "        #suppression du sommet des chemins en cours d'exploration\n",
    "        del E_sommets[s_mini]                                       \n",
    "        \n",
    "        #pour chaque sommet voisin de x\n",
    "        for s in graphe[s_mini]:\n",
    "            if s not in E_calcul:\n",
    "                Maj_poids(s, s_mini, poids,E_sommets)                    \n",
    "                \n",
    "    print(\"calcul \", E_calcul)\n",
    "    return E_calcul"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Travail 3: La vérification de votre implémentation\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def routage(calcul,depart,arrivee):   \n",
    "    \"\"\"\n",
    "    Cette fonction donne le routage d'un point A à B à partir\n",
    "    du résultat obtenu par l'algo de dijkstra\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    calcul : Dict\n",
    "        résultat de l'algo de dijkstra\n",
    "    depart : string\n",
    "        départ\n",
    "    arrivee : string\n",
    "        arrivée\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    routage : list\n",
    "        le routage de A à B\n",
    "    distance : int\n",
    "        la distance\n",
    "\n",
    "    \"\"\"\n",
    "    \n",
    "    routage = [arrivee]\n",
    "    distance=calcul[arrivee][0]\n",
    "    #création de la liste de routage\n",
    "    while routage[0]!= depart:                                     \n",
    "        for key in calcul:\n",
    "            if key==routage[0]:\n",
    "                routage.insert(0,calcul[routage[0]][1])        \n",
    "    return routage,distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calcul  {'A': [0, 'A'], 'C': [2, 'A'], 'B': [4, 'A'], 'D': [5, 'C'], 'H': [6, 'D'], 'F': [8, 'D'], 'E': [9, 'B'], 'G': [9, 'D']}\n",
      "le plus court chemin est:  ['A', 'C', 'D', 'G']\n",
      "la distance parcourue :  9\n"
     ]
    }
   ],
   "source": [
    "resultat = Dijkstra(graph,\"A\")\n",
    "routage, distance= routage(resultat,\"A\",\"G\")\n",
    "print(\"le plus court chemin est: \", routage)\n",
    "print(\"la distance parcourue : \", distance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}