Parcours de graphes

Parcours de graphes

Judicaël Courant 2018-W03-4

1 Parcours de graphes

On veut, en partant d’un sommets, découvrir tous les sommets atteignables par un chemin à partir de celui-ci et leur appliquer une fonctionf.

Dans le cas non-orienté : cet ensemble de sommets est la composante connexe du sommet.

Idée : pour parcourir le graphe à partir des, il suffit de parcourir récursivement le graphe à partir des sommets reliés às.

Problème : on risque de boucler.

Solution : on mémorise l’ensemble des nœuds visités.

Dans ce cours, on s’intéressera à l’algorithme dans le cas orienté (le cas non-orienté peut être vu comme le cas particulier où pour tout arc(s1, s2),(s2, s1)est aussi un arc).

2 Algorithme DFS

Nom de l’algorithme : parcours en profondeur (DFS : Depth-First Search).

Deux implantations possibles (au moins) : 1. récursive ;

2. itérative

2.1 DFS récursif

( ∗ on s e r e s t r e i n t au c a s où l e s sommets s o n t d e s e n t i e r s ∗ ) type sommet == i n t ; ;

( ∗ L ’ e n s e m b l e d e s sommets vus s e r a r e p r é s e n t é par une t a b l e de hachage dont l e s c l é s s o n t d e s sommets . S i un sommet s e s t pr é s e n t dans l a t a b l e , a l o r s c ’ e s t qu ’ i l a é t é vu , s i n o n c ’ e s t qu ’ i l n ’ a pas e n c o r e é t é vu . Comme i l n ’ y a aucune a u t r e i n f o r m a t i o n à a s s o c i e r aux sommets , l e t y p e d e s v a l e u r s a s s o c i é e s s e r a simpl eme nt u n i t ∗ ) type t a b l e _ s o m m e t s == ( sommet , u n i t ) h a s h t b l _ _ t ; ;

( ∗ marque : sommet −> t a b l e _ s o m m e t s −> u n i t Marque l e sommet s comme vu dans l a t a b l e t

∗ )

l e t marque s t = h a s h t b l _ _ a d d t s ( ) ; ;

( ∗ d e j a _ v u : sommet −> t a b l e _ s o m m e t s −> b o o l

( d e j a _ v u s t ) d i t s i l e sommet t a d é j à é t é vu .

∗ )

l e t d e j a _ v u s t =

t r y h a s h t b l _ _ f i n d t s ; t r u e with

| N o t _ f o u n d −> f a l s e

; ;

( ∗ c r e e _ t a b l e : u n i t −> t a b l e _ s o m m e t s

c r é e une t a b l e d e s sommets v i s i t é s , où l e s sommets s o n t d e s e n t i e r s a p p a r t e n a n t à { 0 , . . . , n−1 } .

∗ )

l e t c r e e _ t a b l e ( ) = h a s h t b l _ _ n e w 1 9 7 3 ; ;

( ∗ p a r c o u r s _ p r o f o n d e u r :

( sommet −> u n i t ) −> graphe −> sommet −> u n i t

( p a r c o u r s _ p r o f o n d e u r f g s ) e f f e c t u e un p a r c o u r s en p r o f o n d e u r du graphe g à p a r t i r du sommet s , en a p p l i q u a n t l a f o n c t i o n f à chaque sommet t r o u v é .

∗ )

l e t p a r c o u r s _ p r o f o n d e u r f g s = l e t t = c r e e _ t a b l e ( ) in l e t r e c v i s i t e s 1 =

marque s 1 t ; f s 1 ;

i t e r _ s u c c (fun s 2 −> i f not ( d e j a _ v u s 2 t ) then v i s i t e s 2 ) g s 1 in

v i s i t e s

; ;

Proposition 1 Étant donné un grapheGfini, la fonction de parcours en profondeur récursive donnée ci-dessus termine.

Démonstration : On remarque successivement :

1. Que la seule source potentielle de non-terminaison sont les appels à la fonction récursive visite.

2. Qu’au début de chaque appel devisite s1, on commence par marquers1comme vu avant tout appel récursif éventuel.

3. Qu’on ne peut effectuer un appel récursif devisitesur un sommets2que sis2n’est pas déjà marqué.

On en déduit qu’on ne peut appeler visitequ’au plus une fois sur chaque sommet. Or le

nombre de sommets deGest fini, donc la fonction termine.

2.2 Application

Exercice : étant donné un grapheGnon-orienté etsun sommet deG, calculer la composante connexe des.

Calculer l’ensemble des composantes connexes deG.

2.3 DFS itératif

Idée : simuler les appels récursifs par une pile.

Algorithme :

1. On crée une pile des sommets à visiter en plus de l’ensemble des sommets déjà vus.

2. On empile le premier sommet.

3. Tant que la pile n’est pas vide : a) Dépiler le sommets₁de la pile.

b) Effectuer l’action prévue sur ce sommet.

c) Pour chaque sommets2successeur des1: i. Si le sommets2 a déjà été vu, on ne fait rien.

ii. Sinon, on le marque comme vu et on l’ajoute à la pile.

NB : notez qu’on marque un sommet comme vu potentiellement longtemps avant d’effectuer l’action prévue sur ce sommet. On distinguera donc les sommets :

Vus : ceux qu’on a marqués.

Visités : ceux sur lesquels on a effectué l’action.

( ∗ P a r c o u r s en p r o f o n d e u r , v e r s i o n i t é r a t i v e . Même sp é c i f i c a t i o n que l a v e r s i o n r é c u r s i v e . On u t i l i s e une p i l e . Pour s i m p l i f i e r l ’ é c r i t u r e ,

on d é f i n i t q u e l q u e s f o n c t i o n s a u x i l i a i r e s .

∗ )

l e t c r e e _ e n s e m b l e _ s o m m e t s = s t a c k _ _ n e w ; ; l e t a j o u t e _ s o m m e t = s t a c k _ _ p u s h ; ;

l e t e s t _ v i d e t = s t a c k _ _ l e n g t h t = 0 ; ; l e t c h o i s i s _ s o m m e t = s t a c k _ _ p o p ; ;

l e t p a r c o u r s _ i t e r a t i f f g s = ( ∗ t a b l e d e s sommets vus ∗ ) l e t v u s = c r e e _ t a b l e ( ) in

( ∗ e n s e m b l e d e s sommets à v i s i t e r ∗ ) l e t e = c r e e _ e n s e m b l e _ s o m m e t s ( ) in marque s v u s ;

a j o u t e _ s o m m e t s e ;

while not ( e s t _ v i d e e ) do l e t s 1 = c h o i s i s _ s o m m e t e in f s 1 ;

i t e r _ s u c c (fun s 2 −> i f not ( d e j a _ v u s 2 v u s ) then

( marque s 2 v u s ; a j o u t e _ s o m m e t s 2 e ) ) g s 1

done

; ;

Exercice 1 1. Démontrer que cet algorithme termine. Indications :

a) On peut trouver un invariant reliant les sommets vus, les sommets visités et les sommets dans la pile.

b) Un sommet peut-il être visité deux fois?

2. Démontrer que cet algorithme parcourt tous les sommets atteignables à partir du sommet initial. Indication : trouver un invariant de boucle sur les arcs sortant des sommets visités.

3. Calculer la complexité de cet algorithme dans le cas le pire en fonction du nombre de sommets et du nombre d’arêtes (on supposera qu’on utilise un tableau de listes d’adjacences pour représenter les graphes et que la fonction appliquée à chaque sommet s’exécute en temps constant).

Remarque : la structure de pile est-elle essentielle ici ?

3 Une généralisation

L’algorithme de parcours itératif fonctionne à partir du moment où on a un typeensemble_sommet modélisant des ensembles de sommets et disposant des opérations suivantes :

value c r e e _ e n s e m b l e _ s o m m e t s : u n i t −> e n s e m b l e _ s o m m e t s value a j o u t e _ s o m m e t : e n s e m b l e _ s o m m e t s −> sommet −> u n i t ; ; value e s t _ v i d e : e n s e m b l e _ s o m m e t s −> b o o l ; ;

value c h o i s i s _ s o m m e t : e n s e m b l e _ s o m m e t s −> sommet ; ;

4 BFS

4.1 Première version

BFS : Breadth-First Search, parcours en largeur.

C’est ce qu’on obtient lorsqu’on implante les ensembles avec des files : type e n s e m b l e _ s o m m e t s == sommet q u e u e _ _ t ; ;

l e t c r e e _ e n s e m b l e _ s o m m e t s = queue__new ; ; l e t a j o u t e _ s o m m e t = q u e u e _ _ a d d ; ;

l e t e s t _ v i d e t = q u e u e _ _ l e n g t h t = 0 ; ; l e t c h o i s i s _ s o m m e t = q u e u e _ _ t a k e ; ;

Proposition 2 Dans un parcours en largeur d’un grapheGen partant d’un sommets, on par- court successivements, puis tous les sommets à distance1des, puis ceux à distance2, etc.

On va d’abord modifier un peu notre algorithme avant de montrer cette proposition.

4.2 Calcul de la distance à l’origine

On peut utiliser l’algorithme de parcours en largeur pour calculer la distance au sommet de départsdans un graphe non-pondéré, c’est-à-dire le nombre d’arcsd(s, v)du chemin le plus court entreset un sommetvdonné.

On dira qu’un sommetv⁰est un prédécesseur devsid(s, v) = d(s, v⁰) + 1et qu’il y a une arête dev⁰àv. Tout sommet distinct desadmet au moins un prédécesseur.

Proposition 3 Si, pour toutvdistinct des, on noteP(v)un prédécesseur dev, avecδ=d(s, v), alors en posantv_δ =v,v_δ−1 =P(v_δ),v_δ−2 =P(v_δ−1), ...,v₀ =P(v₁), alorsv₀, ...,v_δest un chemin dans le graphe reliantsàv(on as=v0).

Démonstration : Par récurrence surd(s, v).

On va introduire une table de hachagedistancesdonnantd(s, v)pour chaque sommetv et une tablepreddonnant pour chaque sommetv, un prédécesseur dev.

l e t r e c h e r c h e _ e n _ l a r g e u r f g s = l e t v u s = c r e e _ t a b l e ( ) in

l e t d i s t a n c e s = h a s h t b l _ _ n e w 1 9 7 3 in l e t p r e d = h a s h t b l _ _ n e w 1 9 7 3 in l e t e = queue__new ( ) in

marque s v u s ;

q u e u e _ _ a d d ( s , 0 ) e ;

h a s h t b l _ _ a d d d i s t a n c e s s 0 ; while not ( e s t _ v i d e e ) do

l e t ( s1 , d ) = q u e u e _ _ t a k e e in f s 1 d ;

i t e r _ s u c c (fun s 2 −> i f not ( d e j a _ v u s 2 v u s ) then begin

marque s 2 v u s ;

q u e u e _ _ a d d ( s2 , d + 1 ) e ;

h a s h t b l _ _ a d d d i s t a n c e s s 2 ( d + 1 ) ; h a s h t b l _ _ a d d p r e d s 2 s 1

end) g s 1

done;

( d i s t a n c e s , p r e d )

; ;

Proposition 4 L’algorithme calcule bien la distance desà chaque sommet accessible depuiss (dans un graphe non pondéré) et un prédécesseur pour chaque sommet.

Démonstration : On montre les invariants de boucle suivants :

1. Les sommets vus sont les sommets visités et les sommets dans la file et aucun sommet ne peut être à la fois visité et dans la file.

2. Les sommets visités sont exactement ceux qui sont présents dans la tabledistances. Ce sont aussi ceux qui sont dans la tablepred, plus le sommet initialsqui n’apparaît pas dans la tablepred.

3. Pour tout sommets⁰ vu, la distanceδ(s⁰)indiquée dans la tabledistancesou dans la file vérifieδ(s⁰) ≥d(s, s⁰). De plus, sis⁰ 6=s, le sommets⁰⁰donné par la tablepreda, dans la tabledistances, une valeur indiquéeδ(s⁰⁰)vérifiantδ(s⁰⁰) =δ(s⁰)−1.

4. En notant(x₀, d₀, p₀), . . . ,(xn−1, dn−1, pn−1)lesnéléments de la filet, on ad₀≤. . .≤ dn−1etdn−1≤d0+ 1.

5. Les valeurs données dans la tabledistancessont toutes inférieures ou égales àd0si la file est non-vide.

6. Pour tout arc(s₃, s₄)du graphe, si le sommets₃a été visité, il est dans la tabledistances avec une distance indiquéeδ(s₃)et alors ou biens₄y est aussi, ou bien il est dans la file t. Dans les deux cas, la distanceδ(s4)indiquée pours4est inférieure ou égale àδ(s3)+1.

Considérons un sommets⁰accessible depuisset un chemins₀=s, . . . , s_n=s⁰de longueur ndesàs⁰ dans le graphe. À la fin de l’algorithme, chacun des sommetss0, . . . ,sna été visité et est donc présent dans la tabledistancesavec des valeurs associéesδ(s₀), . . . ,δ(s_n).

D’après l’invariant 6, on a :

δ(s_n)≤1 +δ(sn−1)≤2 +δ(sn−2)≤n+δ(s₀) =n

La valeur δ(s⁰) indiquée dans la table distances pour s⁰ est donc inférieure ou égale à la longueur de tout chemin reliant sà s⁰. En particulier, elle est inférieure ou égale à celle du chemin de longueur minimal, doncδ(s⁰)≤d(s, s⁰).

Comme l’invariant 3 assure de plus qu’on a δ(s⁰) ≥ d(s, s⁰), on en déduit que pour tout sommets⁰accessible depuiss, on a

δ(s⁰) =d(s, s⁰)

L’algorithme de recherche en largeur calcule donc correctement les distances de l’originesà tous les sommets accessibles à partir des.

Par ailleurs, pour tout sommets⁰ distinct de s, en notants⁰⁰le sommet donné par la table predpours⁰, on ad(s, s⁰⁰) =δ(s⁰⁰) =δ(s⁰)−1 =d(s, s⁰)−1, doncs⁰⁰est bien un prédécesseur

des⁰.

5 DFS vs BFS : remarques

Exercice 2 La démonstration précédente s’étend-elle au cas du parcours en profondeur?

1. Complexités temporelles.

2. Complexités spatiales.

Adaptation à des graphes infinis : 1. BFS

2. DFS à profondeur bornée.

3. DFS à profondeur itérée.