Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös

GRAPHES : REPRÉSENTATION ET

PARCOURS

Graphes non-orientés

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös ii

Déf. Un graphe non-orienté est representé par un couple (V,E) où E ⊆(V2

)(paires non-ordonnées).V est l’ensemble des sommets et E est l’ensemble des arêtes.

réseau PPI (protein-protein interaction) : sommets=protéines, arêtes = liaisons

Barabási & Oltvai Nature Rev Genet 5 :101, 2004

Graphes orientés

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös iii

Déf. Un graphe orienté est representé par un couple (V,E) où E ⊆ V × V

(paires ordonnées).V est l’ensemble des nœuds ou sommets, et E est l’ensemble des arcs.

Exemple d’un réseau métabolique (le cycle Krebs) : nœuds = molécules biologiques,arcs = enzymes / réactions chimiques

Terminologie

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös iv

Graphe non-orienté

L’arête {u, v} est dénotée par uv. uv = vu

Si uv ∈ E, alors v est adjacent à u.L’arête uv ∈ E est incidente aux sommets u et v.Le degré de u ∈ V est le nombre d’arêtes qui y sont incidentes.

Graphe orienté

L’arc (u, v) est dénotée par uv : l’arc part de u et arrive à v. uv 6= vu

Si uv ∈ E, alors v est adjacent à u.Le degré sortant de u ∈ V est le nombre d’arcs qui y partent ; le degré rentrant estle nombre d’arcs qui y arrivent.

Comment stocker le graphe ?

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös v

Matrice d’adjacence : matrice V ×V , A[u, v] donne le poids de uv (±∞ ou NaN

pour arcs non-existants), ou valeurs booléennes pour noter juste présence

mémoire Θ(n2) toujours, n = |V |

Listes d’adjacence : liste Adj[u] pour chaque sommet u qui stocke l’ensemble{v : uv ∈ E

}ou l’ensemble des couples

{〈v, c(u, v)〉 : uv ∈ E

}.

mémoire Θ(m) toujours, m = |E|

Déterminer si uv ∈ E ou c(u, v) : rapide avec la matrice mais plus lente avec leslistes d’adjacence

Parcours de voisins de u : rapide avec liste mais lente avec matrice

�en général, on préfère liste d’adjacence

Listes d’adjacence

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös vi

[Wayne & Sedgewick]

Structure typique

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös vii

On veut une structure pour un graphe avec sommets nommés :graphe de symboles : sommets identifiés par clés uniques ∈ U

Composantes de la structure :? table de symboles pour indexage de sommets : U → {0,1 . . . , n − 1}

(tableau de hachage ou ABR)? index inversé : {0,1 . . . , n− 1} → U (tableau de taille n)? tableau de listes d’adjacence

Graphe de symboles

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös viii

� facile à élargir en stockant de l’information associée avec les sommets dans un tableau de taille n

[Sedgewick & Wayne]

Rappel : parcours d’un arbre

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös ix

Un parcours visite tous les nœuds de l’arbre.? parcours préfixe (preorder traversal ) : chaque nœud est visité avant que

ses enfants soient visités.? parcours postfixe (postorder traversal ) : chaque nœud est visité après que

ses enfants sont visités.

Parcours avec pile

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös x

Algo PARCOURS-PILE

1 initialiser la pile P

2 P.push(root)

3 while P 6= ∅4 x← P.pop()

5 if x 6= null then

6 «visiter» x

7 for y ∈ x.children do P.push(y)

� cela donne un parcours préfixe

Parcours avec queue = par niveau

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös xi

Algo PARCOURS-NIVEAU

1 initialiser la queue Q

2 Q.enqueue(root)

3 while Q 6= ∅4 x← Q.dequeue()

5 if x 6= null then

6 «visiter» x

7 for y ∈ x.children do Q.enqueue(y)

� PARCOURS-NIVEAU(root) visite tous les nœuds dans l’arbre dans l’ordre de niveaux

Parcours de graphe

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös xii

Idée générale :? suivre toujours une arête‘uv qui mène à partir d’un sommet visité u à un

sommet non-visité v

? marquer les sommets visités pour ne pas boucler à l’infini sur un cycle dansle graphe

Parcours par profondeur : choisir l’arête/arc uv où u est visité le plus récemment(pile)

Parcours par largeur : choisir l’arête/arc uv où u est visité le moindre récemment(queue)

Parcours en largeur - BFS

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös xiii

breadth-first search : utiliser une file FIFO (queue) Q

(init) for u← 0,1, . . . , n− 1 do marked[u]← falseBFS(s) // parcours en largeur à partir de sommet s

B1 d[s]← 0; parent[s]← s

B2 marked[s]← true;Q.enqueue(s) ;B3 while (Q 6= ∅) doB4 u← Q.dequeue()B5 for uv ∈ Adj[u] do if (¬marked[v]) thenB6 d[v]← d[u] + 1; parent[v]← u

B7 marked[v]← true;Q.enqueue(v)

Théorème. Le parcours en largeur prend O(n + m) temps sur un graphe de n

sommets et m arêtes s’il est stocké par listes d’adjacence.

Plus courts chemins

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös xiv

Théorème. À la fin du parcours, d[u] est la longueur minimale d’un cheminentre s et u pour tout sommet u. On peut retracer ce plus court chemin en suivantles liaisons parent.

0 1

1 1 2

3départ

4

3

�BFS trouve les plus courts chemins à partir d’une source

Parcours en profondeur — DFS

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös xv

depth-first search

Technique essentielle : marquage/coloriageverte=«jamais vu», jaune=«presque vu», rouge=«déjà vu»

(init) parent[s]← s ; for u← 0,1, . . . , n− 1 do couleur[u]← verteDFS(s) // parcours en profondeur à partir de sommet s

D1 couleur[s]← jaune // prévisite de s

D2 for st ∈ Adj[s] do // pour tout sommet t adjacent à sD3 if couleur[t] = verte then DFS(t) ; parent[t]← s // visite du voisin t

D4 couleur[s]← rouge // post-visite de s

� c’est la généralisation du parcours préfixe ou postfixe sur les arbres

� ici, on stocke le parent et colorie en rouge juste pour une raison didactique

il suffit de marquer les sommets visités ou non : jaune ou vert

DFS 2

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös xvi

J V

J J J

R

prochaine arête à explorer

départR

R

arêteretour

arête de liaison

sommet actif (s)

1

2 3

4

5

68

7

t

toute arête est visité deux fois (car elle est sur deux listes d’adjacence)quand on visite une arête st pour la première fois, la couleur du sommet t peut être

verte : si arête st et sommet t découverts pour la première fois� c’est une arête de liaison

jaune : si arête st découverte pour la première fois, mais t est connu� c’est une arête retour

rouge : impossible, car on a dû visiter toutes les arêtes adjacentes, incluant ts,avant de rougir t.

DFS 3

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös xvii

On explore le graphe entier en lançant DFS à partir de tout sommet qui reste vert :

for s← 0,1, . . . n− 1 do if couleur[s] = verte then DFS(s)

Théorème. Le parcours en profondeur d’un graphe avec n sommets et m arêtesfinit en temps O(n + m).

Preuve. On considère chaque arête exactement deux fois (quand on la trouve sur les deux listes

d’adjacence), et on colorie chaque sommet exactement trois fois. �

forêt en profondeur : formée par les arêtes de liaison parenten suivant les liaisons parent, on trouve un chemin entre un sommet quelconque v

et le sommet de départ : c’est le chemin formé par les sommets jaunes quand v aété découvert

pathTo(x) // chemin à sommet x à partir du sommet de source après l’appel DFS(s)P1 initialiser pile vide P ; if couleur[x] = verte then return P // aucun cheminP2 y ← parent[x] ; while x 6= y do P.push(x);x← y; y ← parent[x]P3 P.push(x)P4 return P

Forêt en profondeur

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös xviii

!"# $%&'(&)* +, #%-"#( *%$# of this page, which show the progress of DFS and BFS for our sample graph mediumG.txt, make plain the differ-ences between the paths that are dis-covered by the two approaches.DFS wends its way through the graph, stor-ing on the stack the points where other paths branch off; BFS sweeps through the graph, using a queue to remember the frontier of visited places. DFS ex-plores the graph by looking for new vertices far away from the start point, taking closer vertices only when dead ends are encountered; BFS completely covers the area close to the starting point, moving farther away only when everything nearby has been examined. DFS paths tend to be long and wind-ing; BFS paths are short and direct. Depending upon the application, one property or the other may be desirable (or properties of paths may be imma-terial). In .#/-%+, 0.0, we will be con-sidering other implementations of the Paths API that find paths having other specified properties.

BFS for shortest paths (250 vertices)

20%

40%

60%

80%

100%

DFS for paths (250 vertices)

20%

40%

60%

80%

100%

542 CHAPTER 4 Q Graphs

[Sedgewick & Wayne]

Composantes connexes

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös xix

identifier les composantes connexes dans un graphe :on veut une opération de test s’il existe un chemin entre u et v

C1 for u← 0,1, . . . , n− 1 do marked[u]← false ; id[u]← u

C2 c← 0 // compteur de composantes connexesC3 for u← 0,1, . . . , n− 1 doC4 if (¬marked[u]) then c← c + 1; DFSCOMP(u, c) // parcours de composante c

DFSCOMP(s, c) // parcours dans composante c à partir de sommet sD1 marked[s]← true ; id[s]← c // composante pour s déterminée à prévisiteD2 for st ∈ Adj[s] do if

(¬marked[t]

)then DFSCOMP(t, c)

maintenant, id[u] = id[v] si et seulement si u et v appartiennent à la mêmecomposante (↔ il existe un chemin entre eux)

�union-find peut aussi implanter cette opération, mais au lieu d’un ordre quelconque, DFS établit

un ordre spécifique de tracer les liaisons

DFS : cycles

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös xx

détection de cycles :

B1 for u← 0,1, . . . , n− 1 do marked[u]← false

B2 cycles← false

B3 for u← 0,1, . . . , n− 1 do

B4 if (¬marked[u]) then DFSCYC(u, u)

DFSCYC(v, u) // arête de liaison uv

D1 marked[v]← true

D2 for vw ∈ Adj[v] do

D3 if (¬marked[w]) then DFSCYC(w, v)

D4 else if w 6= u then cycles← true // on a trouvé un cycle

Parcours de graphe orienté

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös xxi

Liste d’adjacence = liste d’arcs sortants

Mêmes techniques algorithmiques : DFS et BFS sans changement

exemple : DFS trouve les sommets accessibles→ ramasse-miette

because DFS is fundamentally a digraph-processing algorithm, with one representation of each edge. Following this trace is a worthwhile way to help cement your understand-ing of depth-first search in digraphs.

Mark-and-sweep garbage collection. An im-portant application of multiple-source reach-ability is found in typical memory-management systems, including many implementations of Java. A digraph where each vertex represents an object and each edge represents a reference to an object is an appropriate model for the memory usage of a running Java program. At any point in the execution of a program, certain objects are known to be directly accessible, and any object not reachable from that set of objects can be returned to available memory. A mark-and-sweep garbage collection strategy reserves one bit per object for the purpose of garbage collection, then periodically marks the set of potentially accessible objects by running a di-graph reachability algorithm like DirectedDFSand sweeps through all objects, collecting the unmarked ones for use for new objects.

Finding paths in digraphs. DepthFirstPaths (Algorithm 4.1 on page 536) and BreadthFirstPaths (Algorithm 4.2 on page 540) are also fundamentally digraph-processing algorithms. Again, the identical APIs and code (with Graph changed to Digraph) effectively solve the following problems:

Single-source directed paths. Given a digraph and a source vertex s, support queries of the form Is there a directed path from s to a given target vertex v? If so, find such a path.

Single-source shortest directed paths. Given a digraph and a source vertex s, support queries of the form Is there a directed path from s to a given target vertex v? If so, find a shortest such path (one with a minimal number of edges).

On the booksite and in the exercises at the end of this section, we refer to these solu-tions as DepthFirstDirectedPaths and BreadthFirstDirectedPaths, respectively.

Garbage collection scenario

directlyaccessibleobjects

potentially accessible

objects

objects available

for collection

5734.2 Q Directed Graphs

Tri topologique

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös xxii

Problème de tri topologique, ou ordonnancement de tâches :On a une liste de tâches X , avec des contraintes capturés par l’ordre partiel «xdoit être complété avant y», dénoté par x 4 y. On veut trouver un arrangementséquentiel qui assure que x est complété avant y quand x 4 y.

⇒ abstraction : graphe orienté acyclique (antisymétrie + transitivité = aucun cycleorienté)

on veut alors permutation de sommets telle que pour tout arc uv, u se trouveavant v dans la permutation

Tri topologique avec DFS

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös xxiii

(init) parent[s]← s ; for u← 0,1, . . . , n− 1 do couleur[u]← verteDFS(s) // parcours en profondeur à partir de sommet s

D1 couleur[s]← jaune // prévisite de s

D2 for st ∈ Adj[s] do // pour tout sommet t adjacent à sD3 if couleur[t] = verte then DFS(t) ; parent[t]← s // visite du voisin t

D4 couleur[s]← rouge // post-visite de s

l’ordre des nœuds à post-visite : quand on appelle DFS(s), pour tout arc st :? si t est verte, alors DFS(t) va être executé avant que DFS(s) finit? si t est rouge, alors DFS(t) a été déjà executé? si t est jaune, on a un problème : chemin t → s existe (chaîne d’appels

récursifs)⇒ le graphe n’est pas acylique⇒ l’ordre post-visite est l’inverse de l’ordre souhaité

Tri topologique 2

Graphes ? IFT2015 H2020 ? UdeM ? Miklós Csűrös xxiv

T1 for u← 0,1, . . . , n− 1 do marked[u]← falseT2 for u← 0,1, . . . , n− 1 do if (¬marked[u]) then DFSTOPO(u)

DFSTOPO(s) // parcours en profondeur à partir de sommet sD1 marked[s]← true ; for st ∈ Adj[s] do if (¬marked[t]) then DFSTOPO(t) ;D2 P.push(s)

À la fin, P.pop défile dans l’ordre topologique.