from collections import deque ;
f = deque([depart]). Avec f.append(v) pour enfilerf.popleft() pour défiler, en $O(1)$ chacun.]]>listappend 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 crucial : sans lui, sur undef bfs(g, depart):
visites = {depart}
pile = [depart]
while pile:
v = pile.pop()
for w in g[v]:
if w not in visites:
visites.add(w)
pile.append(w)
return visites]]>pile.pop() retire le dernierdeque avecpopleft.]]>def bfs(g, depart):
visites = {depart}
from collections import deque
f = deque([depart])
while f:
v = f.popleft()
for w in g[v]:
if w not in visites:
visites.add(w)
f.append(w)
return visites]]>visites pour éviter les bouclesdef bfs(g, depart):
return g[depart]]]>def bfs(g, depart):
from collections import deque
f = deque([depart])
resultat = []
while f:
v = f.popleft()
resultat.append(v)
for w in g[v]:
f.append(w)
return resultat]]>visites, chaqueg = {'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).A-B (4), A-C (2), B-C (1), B-D (5),C-D (8), C-E (10), D-E (2). On lanceA. Quelle est laA à E ?]]>dist[v] pour chaque sommet. Tant qu'ildist[w] = min(dist[w], dist[v] + poids(v,w)).A-B-D-E)]]>C permet d'atteindreB à coût $3$ (au lieu de $4$), ce quiC-E)]]>A → C → E), mais ce n'est pasA → C → B → D → E totaliseA → B → D → E pèse bienA → C → E pèse $12$ etA → C → B → D → E pèseA ($0$), on met à jour B=4, C=2.C (le plusB = min(4, 2+1) = 3, D = 2+8 = 10,E = 2+10 = 12. Étape 3 : on extraitB ($3$), on met à jourD = min(10, 3+5) = 8. Étape 4 : onD ($8$), on met à jourE = min(12, 8+2) = 10. Étape 5 : onE ($10$), parcours terminé.A → C → B → D → E de poids totalgdepart ?]]>RecursionError sur les trèsdef parcours_profondeur(g, depart, visites=None):
if visites is None:
visites = []
visites.append(depart)
for voisin in g[depart]:
if voisin not in visites:
parcours_profondeur(g, voisin, visites)
return visites]]>visites, puisvisites=None puisg = {"A": ["B", "C"], "B": ["A", "D"], "C": ["A", "D"], "D": ["B", "C"]},parcours_profondeur(g, "A")['A', 'B', 'D', 'C'].]]>def parcours_profondeur(g, depart):
for voisin in g[depart]:
parcours_profondeur(g, voisin)]]>RecursionError. Ladef parcours_profondeur(g, depart, visites=None):
if visites is None:
visites = []
visites.append(depart)
for voisin in g[depart]:
if voisin not in visites:
parcours_profondeur(g, voisin)
return visites]]>visites, donc chaque appel repart d'uneRecursionError.]]>def parcours_profondeur(g, depart, visites={}):
visites[depart] = True
for voisin in g[depart]:
if voisin not in visites:
parcours_profondeur(g, voisin, visites)
return visites]]>visites = {}parcours_profondeur(g, ...) partagentA, B, C etD, un appel sur un autre graphe{"X": ["Y"], "Y": ["X"]} renvoie unA,B, C et D en plus de X et Y.]]>- $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 ?