f = [depart], puis f.append(v) pour enfilerf.pop(0) pour défiler au début.pop(0) décale tous les éléments restants ; unelistappend et pop).]]>Grapheajouter_sommet, ajouter_arete,voisins, etc. Plus propre pour des projetsg = {'A': ['B', 'C'], 'B': ['A'], 'C': ['A']}.depart dans un graphe g (dictionnaire) ?]]>visites est cruciale : sans elle, sur undef parcours_largeur(g, depart):
visites = [depart]
pile = [depart]
while len(pile) > 0:
v = pile.pop()
for w in g[v]:
if w not in visites:
visites.append(w)
pile.append(w)
return visites]]>pile.pop() retire le dernierpop(0).]]>def parcours_largeur(g, depart):
visites = [depart]
file = [depart]
while len(file) > 0:
v = file.pop(0)
for w in g[v]:
if w not in visites:
visites.append(w)
file.append(w)
return visites]]>file.pop(0) retire le sommet ajoutévisites évite de réenfiler un sommet déjàdef parcours_largeur(g, depart):
return g[depart]]]>def parcours_largeur(g, depart):
file = [depart]
resultat = []
while len(file) > 0:
v = file.pop(0)
resultat.append(v)
for w in g[v]:
file.append(w)
return resultat]]>visites, chaqueA à la ville B, quelle que soit sa longueur. Quelle méthodeA.]]>A visite exactement les sommetsA, en vérifiant si B est visité]]>A, dans des ordres différents. B est visitéA à B.]]>g = {'A': ['B', 'C'], 'B': ['A', 'C'], 'C': ['A', 'B']}.[A, B, C] ?]]>[[0, 1, 0],
[1, 0, 1],
[0, 1, 0]]]]>A - B - C, où A et CA et C sont voisins.]]>[[0, 1, 1],
[1, 0, 1],
[1, 1, 0]]]]>[[0, 0, 0],
[0, 0, 0],
[0, 0, 0]]]]>[[1, 1, 1],
[1, 1, 1],
[1, 1, 1]]]]>g['A'] ne contient pas 'A').]]>g = {'A': ['B', 'C'], 'B': ['A', 'D'], 'C': ['A', 'D'], 'D': ['B', 'C', 'E'], 'E': ['D']}'A', en visitant les voisinsA,A et on enfile ses voisinsB et C. On défile B, on enfile DA est déjà visité). On défile C (sesA et D sont déjà visités ouD, on enfile E. OnE. Ordre de visite : A, B, C, D, E.]]>A,B puis C. Donc B est visitéC, pas l'inverse.]]>D avant E car D estB), et E n'estD).g et la fonction suivants :
g = {"A": ["B", "C"], "B": ["A", "D"], "C": ["A", "E"],
"D": ["B", "E"], "E": ["C", "D"]}
def chemin(g, depart, arrivee):
parent = {depart: depart}
file = [depart]
while len(file) > 0:
s = file.pop(0)
for v in g[s]:
if v not in parent:
parent[v] = s
file.append(v)
resultat = [arrivee]
s = arrivee
while s != depart:
s = parent[s]
resultat.append(s)
return resultatQue renvoie chemin(g, "A", "E") ?
['A', 'C', 'E']]]>C, mais la fonction le construitarrivee et en remontant les parents. La'E'.]]>['E', 'C', 'A']]]>'A' comme parent de 'B''C', puis 'B' comme parent de 'D' et 'C' comme parent'E', car C sort de la file avant D. En remontant depuisE, on obtient E, C, puis A.]]>['E', 'D', 'B', 'A']]]>E est découvert depuis C, qui sort de la file avantD. Son parent est donc C et non D, et le chemin reconstituéB.]]>['A', 'B', 'D', 'E']]]>A → C → E n'enarrivee. Le parcours en largeur retient un chemin au nombregdepart, appelé sous la formeparcours_profondeur(g, depart, []) ?]]>visites. Pour de très grandsRecursionError.]]>def parcours_profondeur(g, depart, visites):
visites.append(depart)
for voisin in g[depart]:
if voisin not in visites:
parcours_profondeur(g, voisin, visites)
return visites]]>visites, puis on appelle récursivement la fonction surg = {"A": ["B", "C"], "B": ["A", "D"], "C": ["A", "D"], "D": ["B", "C"]},parcours_profondeur(g, "A", []) renvoie['A', 'B', 'D', 'C'].]]>def parcours_profondeur(g, depart, visites):
visites.append(depart)
for voisin in g[depart]:
parcours_profondeur(g, voisin, visites)
return visites]]>B est voisin de A et A voisin de B :RecursionError.]]>def parcours_profondeur(g, depart, visites):
visites.append(depart)
for voisin in g[depart]:
if voisin not in visites:
parcours_profondeur(g, voisin, [])
return visites]]>visites, donc chaque appel oublie lesRecursionError.]]>def parcours_profondeur(g, depart, visites):
visites.append(depart)
for voisin in g[depart]:
if voisin not in visites:
return parcours_profondeur(g, voisin, visites)
return visites]]>return placé dans la boucle arrête{"A": ["B", "C"], "B": ["A"], "C": ["A"]}, l'appelA renvoie ['A', 'B'] et oublie C.]]>- $A$ est relié à $B$ et $C$ ;
- $B$ est relié à $D$ ;
- $C$ est relié à $D$ et $E$ ;
- $D$ est relié à $E$.
On suppose que, à chaque sommet visité, les voisins sont
examinés dans l'ordre alphabétique. Dans quel ordre les
sommets sont-ils découverts ?
g = {"A": ["B", "C"], "B": ["A"], "C": ["A", "D"], "D": ["C"]}A vers B, et aucun de BA. Où cet arc apparaît-il dans le dictionnaire desA seulement, qui contient B]]>B est successeur de A, mais A n'est pas successeur deB.]]>A et de B, comme toute arête]]>B seulement, qui contient A]]>B vers A.]]>