Annexe optionnelle — Dijkstra avec une structure de données en dictionnaire

2ème mise en œuvre de l'algorithme de Dijkstra

VERSION corrigée

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.

Conditions de réalisation de l'évaluation:

Travail en binome.
A rendre dans un délai de 15 jours après la séance.
soit en complétant le notebook fourni soit sous la forme d'un fichier exécutable .py.

1- Présentation

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. Le graphe : 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.

2- Représentation du graphe par un dictionnaire

Travail 1 : définir la structure de donnée

Définir la structure de donnée pour représenter le graphe sous forme d’un dictionnaire. 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.

In [7]:

#création du dictionnaire du graphe pondéré pour la recherche du plus court chemin
graph = {
'A': {'B': 4, 'C': 2},
'B': {'A': 4, 'C': 6, 'E':5},
'C': {'A': 2, 'B': 6, 'D': 3, 'H' : 5},
'D': {'C': 3, 'H': 1, 'G': 4, 'F': 3},
'E': {'B': 5, 'F': 2},
'F': {'E': 2, 'D': 3, 'G': 7},
'G': {'F': 7, 'D': 4, 'H': 10},
'H': {'C': 5, 'D': 1, 'G': 10},
}

Vous avez la possibilité de revenir vers l’enseignant pour valider votre solution.

3- Implémentation de l'algorithme de Dijkstra

Travail 2 : implémenter votre solution

Votre solution sera documentée et s'appuiera sur le travail réalisé en classe.

In [8]:

def initialisation(s_debut):
    """
    initialisation des variables permettant de parcourir le graphe
    Parameters
    ----------
    depart : string
        sommet de depart pour le parcours du graphe.
    Returns
    -------
    E_calcul : dict
        chemin en cours de calcul: poids et sommet précédent
        E_calcul = {s_debut:[poids,prédécesseur]}
        la distance au sommet de depart est nulle
    E_sommets : dict
        on met dans le dictionnaire provisoire les sommets adjacents 
        et leur poids par rapport au point de départ
        E_sommets = {s_voisin1: [poids,depart],...}
    """
    assert type(s_debut) == str, " s_debut doit être un caractère "
    
    E_calcul = dict()
    E_calcul = {s_debut:[0,s_debut]}
    
    E_sommets=dict()
    for suivant in graph[s_debut]:
        #chemins en cours d'exploration : sommet: poids, précédent
        E_sommets[suivant]=[graph[s_debut][suivant],s_debut]

    return E_calcul,E_sommets

In [9]:

def Maj_poids(s_voisin,s_mini,poids, E_sommets):
    """
    Mise à jour du poids et du prédécesseur
    
    Parameters
    ----------
    s_voisin : str
        sommet voisin
    s_mini : str
        sommet de poids mini
    poids : int
        poids du chemin le plus court 
    E_sommets : dict
        dictionnaire des chemins en cours d'exploration'

    Returns
    -------
    E_sommets : dict
        dictionnaire des chemins en cours d'exploration mise à jour
        avec le poids et le sommet de poids mini

    """
    #si le sommet est nouveau
    #mettre àjour poids et prédecesseur
    if s_voisin in E_sommets: 
        d=poids + graph[s_mini][s_voisin]
        if d< E_sommets[s_voisin][0]:
            #mémoriser son prédécesseur et le poids depuis le début
            E_sommets[s_voisin] = [d,s_mini]
    else:
        #si le sommet est déjà découvert mettre à jour le poids
        E_sommets[s_voisin]=[poids + graph[s_mini][s_voisin],s_mini]
    return E_sommets

In [10]:

def Dijkstra(graphe, s_debut):
    """
    Cette fonction implémente l'algorithme de dijkstra
    Parameters
    ----------
    graphe : dict
        DESCRIPTION. description du graphe
    s_debut : str
        DESCRIPTION. le sommet de départ

    Returns
    -------
    calcul: dict
        le résultat de l'algorithme de dijkstra

    """
    assert type(s_debut) == str, " s_debut doit être un caractère "
    assert type(graphe)   == dict, "graphe doit être un dictionnaire"
    
    
    #phase d'initialisation des données
    E_calcul,E_sommets=initialisation(s_debut)
    
    #tant que provisoire non vide
    while E_sommets!= {}:                                      
        #recherche de la distance la plus faible
        s_mini=min(E_sommets, key=E_sommets.get)                   
        #ajout du sommet de valeur minimum aux sommets explorés
        E_calcul[s_mini]=E_sommets[s_mini]
        poids = E_sommets[s_mini][0]
        
        #suppression du sommet des chemins en cours d'exploration
        del E_sommets[s_mini]                                       
        
        #pour chaque sommet voisin de x
        for s in graphe[s_mini]:
            if s not in E_calcul:
                Maj_poids(s, s_mini, poids,E_sommets)                    
                
    print("calcul ", E_calcul)
    return E_calcul

In [ ]:

Travail 3: La vérification de votre implémentation

In [11]:

def routage(calcul,depart,arrivee):   
    """
    Cette fonction donne le routage d'un point A à B à partir
    du résultat obtenu par l'algo de dijkstra

    Parameters
    ----------
    calcul : Dict
        résultat de l'algo de dijkstra
    depart : string
        départ
    arrivee : string
        arrivée

    Returns
    -------
    routage : list
        le routage de A à B
    distance : int
        la distance

    """
    
    routage = [arrivee]
    distance=calcul[arrivee][0]
    #création de la liste de routage
    while routage[0]!= depart:                                     
        for key in calcul:
            if key==routage[0]:
                routage.insert(0,calcul[routage[0]][1])        
    return routage,distance

In [12]:

resultat = Dijkstra(graph,"A")
routage, distance= routage(resultat,"A","G")
print("le plus court chemin est: ", routage)
print("la distance parcourue : ", distance)

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']}
le plus court chemin est:  ['A', 'C', 'D', 'G']
la distance parcourue :  9