Jour : 15 février 2021

Implémentation des graphes en Python par l’exemple : Le parcours en largeur python d’un graphe (BFS) est un algorithme utilisé pour parcourir les structures de donnée de graphe. BFS met en œuvre une stratégie spécifique pour visiter tous les sommets d’un graphe.

Introduction – Implémentation des graphes en Python

BFS commence par un sommet, puis il vérifie les voisins du sommet initial, puis les voisins des voisins, etc.

En entrée de l’algorithme il y a le graphe G et un sommet de départ D pour lequel on considère que la distance est 0.

En sortie de l’algorithme sont calculées toutes les distances entre le sommet D et chaque sommet du graphe G ainsi que l’arbre couvrant si le graphe G est connexe (c’est à dire que pour toute paire de sommet il existe un chemin entre eux dans le graphe).

Description de l’algorithme

On utilise les tableaux suivants :

• Distance[.] : Stocke la distance entre D (sommet de départ) et un autre sommet du graphe.
• Father[.] : Stocke le sommet père d’un sommet du graphe parcouru.
• Visite[.] : Stocke l’état de visite du sommet, liste des valeurs possible 0:pas encore visité,1:Visite en cours,2:Visité

On utilise les fonctions suivantes pour une file F :

• First(F) : Retourne l’élément en tête de la file F sans le supprimer.
• Dequeue(F) : Retourne l’élément en tête de la file F en le supprimant.
• Append(F, A) : Mettre l’élément A dans la file F en queue de la file.

Les étapes de l’algorithme :

• Phase d’initialisation
  • 1. Pour tous les sommets faire
    • Visite = 0 (Pas encore visité)
    • Pere = null (Initialise le tableau)
    • Distance = -1
  • 2. Append(F,D) (ajoute l’élément de départ)
  • 3. Distance[R] = 0 (postulat de départ)
• Phase d’action (parcours du graphe G)
  • Tant que la file F n’est pas vide
    • t = First(F)
    • Pour tous les voisins v de t faire
      • Si Visite[v] = 0 (sommet non visité) alors
        • Visite[v] = 1 (Visite en cours)
        • Distance[v] = Distance[t] + 1
        • Father[v] = t
        • Append(F,v)
    • Dequeue(F)
    • Visite[t] = 2

Si on détaille les étapes avec le cas du graphe exemple ci-dessous.

Phase d’initialisation :

Initialisation l’élément A est l’élément de départ à distance 0, il est coloré en orange pour indiquer que la visite est en cours.

Visite des voisins du sommet A (Visite du sommet B)

implémentation des graphes en python – Visite des voisins du sommet A (Visite du sommet C)

Marquage de A comme visité et suppression de la file

Visite des voisins du sommet B (Visite du sommet D)

Marquage de B et C comme visité et suppression de la file

Marquage de D comme visité et fin de l’algorithme

Construction de l’arbre couvrant si le graphe est connexe

Application : Le parcours en largeur d’un graphe (BFS) est utile pour :

• Vérifier si un graphe est connexe (tous les sommets sont alors marqués comme visités à la fin de l’algorithme).
• Calculer les distances à partir d’un sommet donné
• Construire un arbre couvrant du graphe

from collections import deque
def bfs(graph, vertex):
    queue = deque([vertex])
    distance = {vertex: 0}
    pere = {vertex: None}
    while queue:
      t = queue.popleft()
      for voisin in graph[t]:
        if voisin not in distance:
          queue.append(voisin)
          distance[voisin] = distance[t] + 1
          pere[voisin] = t
    return distance, pere
#Liste d'ajacence du graphe
graph = {
  'A': ['B','C'],
  'B': ['A','C', 'D'],
  'C': ['D'],
  'D': ['C','A']
}
distance,pere = bfs(graph,'A')
print("Distances" + str(distance))
print("Pere = " + str(pere))

Parcours en largeur python – Liens externes

https://fr.wikipedia.org/wiki/Python_(langage)

https://www.python.org/

https://fr.wikipedia.org/wiki/Algorithme_de_parcours_en_largeur

Implémentation des graphes en python – Liens internes

https://128mots.com/index.php/category/python/

Algorithme glouton python – Exemple rendu de monnaie