Parcours de graphes jeanjacqueslevy.net

(1)

Inf 431 – Cours 1

Parcours de graphes

secr´etariat de l’enseignement:

Catherine Bensoussan [email protected]

Aile 00, LIX, 01 69 33 34 67

(2)

Objectifs de INF 431

• Principes de la Programmation (2`eme partie)

• Modularit´e – Programmation par objets

• Graphes, Grammaires, Concurrence

• Initiation `a l’informatique scientifique

Format du cours

• D´ebut encadr´e (Amphi + Petite Classe + TD)

• Milieu (Amphi + Petite Classe + Devoir Maison)

• Fin (Amphi + Projet Informatique)

Notation

• CC 4h + PI ; 2 DMs

• note module = max{CC, (12 ∗ CC+ 6 ∗ PI)/18}

note lit´erale = note module + DMs/6 DMs = 6(A),4(B),2(C),1(D),0(E)

(3)

Plan

1. Files d’attente 2. Piles

3. Graphes

4. Repr´esentation des graphes 5. Parcours en profondeur

6. Parcours en largeur

7. Arbres de recouvrement 8. Sortie de labyrinthe

(4)

File d’attente (1/4)

debut

out in

fin

Deux repr´esentations. Dans un tableau (tampon circulaire).

fin debut

ou par une liste.

fin debut

(5)

File d’attente (2/4)

Premier arriv´e, premier servi (First In, First Out).

Structure de données très fréquente dans les programmes : par exemple dans les OS, le temps-réel, . . . et le hardware.

Une première méthode compacte consiste à gérer un tampon circulaire.

class FIFO {

int debut, fin;

boolean pleine, vide;

int[ ] contenu;

FIFO (int n) {

debut = 0; fin = 0; pleine = n == 0; vide = true;

contenu = new int[n];

}

(6)

File d’attente (3/4)

static void ajouter (FIFO f, int x) { if (f.pleine)

throw new Error ("File Pleine.");

f.contenu[f.fin] = x;

f.fin = (f.fin + 1) % f.contenu.length;

f.vide = false; f.pleine = f.fin == f.debut;

}

static int supprimer (FIFO f) { if (f.vide)

throw new Error ("File Vide.");

int res = f.contenu[f.debut];

f.debut = (f.debut + 1) % f.contenu.length;

f.vide = f.fin == f.debut; f.pleine = false;

return res;

}

Belle sym´etrie. Taille ' n.

Taille born´ee (structure de donn´ee statique).

Complexit´e de ajouter et supprimer en O(1).

(7)

Rappel de notions de Java

Un programme de test avec comme arguments :

la taille, les éléments à ajouter, les ordres de suppression

Exemple d’ex´ecution :

% javac FIFO.java

% java FIFO 10 3 4 5 - - 7 8 - - 9 3

4 5 7

public static void main (String[ ] args) { int n = Integer.parseInt (args[0]);

FIFO f = new FIFO (n);

for (int i = 1; i < args.length; ++i) if (args[i].equals ("-") )

System.out.println (supprimer(f));

else {

int x = Integer.parseInt (args[i]);

ajouter (f, x);

} }

(8)

File d’attente (4/4)

class FIFO {

Liste debut, fin;

FIFO () { debut = null; fin = null; } static void ajouter (FIFO f, int x) {

if (f.fin == null) f.debut = f.fin = new Liste (x);

else {

f.fin.suivant = new Liste (x);

f.fin = f.fin.suivant;

} }

static int supprimer (FIFO f) {

if (f.debut == null) throw new Error ("File Vide.");

else {

int res = f.debut.val;

if (f.debut == f.fin) f.debut = f.fin = null;

else f.debut = f.debut.suivant;

return res;

} }

Taille non born´ee (structure de donn´ee dynamique) en 2n.

Complexit´e de ajouter et supprimer en O(1).

(9)

Pile (1/3)

sommet

out in

Deux repr´esentations. Dans un tableau hauteur

ou par une liste.

sommet

(10)

Pile (2/3)

Dernier arriv´e, premier servi (Last In, First Out).

Utile en compilation, en informatique th´eorique.

class Pile { int hauteur ; int[ ] contenu;

Pile (int n) {hauteur = 0; contenu = new int[n]; } static void empiler (int x, Pile p) {

if (p.hauteur >= p.contenu.length) throw new Error ("Pile pleine.");

p.contenu[p.hauteur++] = x;

}

static int depiler (Pile p) { if (p.hauteur <= 0)

throw new Error ("Pile vide.");

return p.contenu [--p.hauteur];

}

Taille born´ee (structure de donn´ee statique).

Complexit´e de empiler et depiler en O(1).

(11)

Pile (3/3)

class Pile { Liste sommet;

Pile () { sommet = null; }

static void empiler (int x, Pile p) { p.sommet = new Liste (x, p.sommet);

}

static int depiler (Pile p) {

if (p.sommet == null) throw new Error ("Pile vide.");

int res = p.sommet.val;

p.sommet = p.sommet.suivant;

return res;

}

Taille non born´ee (structure de donn´ee dynamique).

Complexit´e de empiler et depiler en O(1).

Loi

[Randell et Russel, 1960]

R´ ecursif = It´ eratif + Pile

⇒ premiers compilateurs

(12)

Graphe (1/3)

Un graphe G = (V, E) a un ensemble de sommets V et d’arcs E ⊂ V × V . Un arc e = (v₁, v₂) a pour origine org(e) = v₁ et pour extr´emit´e

ext(e) = v₂.

Un graphe est une relation binaire sur ses sommets.

Exemples : les rues de Paris, le plan du m´etro.

G = (V, E) est un graphe non orient´e ssi (v₁, v₂) ∈ E implique (v₂, v₁) ∈ E.

Par exemple, les couloirs de l’X.

Un chemin est une suite d’arcs e₁, e₂, . . .e_n, telle que ext(e_i) = org(e_i+1) pour 1 ≤ i < n, o`u n ≥ 0. Un circuit (ou cycle) est un chemin o`u

ext(e_n) = org(e₁).

Les dag (directed acyclic graphs) sont des graphes orient´es sans cycles.

Exemple : le graphe des d´ependances entre modules pour la cr´eation d’un projet informatique. (Makefile)

Un arbre est un dag. Une forˆet (ensemble d’arbres) est un dag.

(13)

Graphe (2/3)

0 0 0

0 0 1

1 0 1

1 1 1 1

1 0 0 1 0

1 0 0

0 1 1

Graphe de de Bruijn

(14)

Graphe (3/3)

2

4 8

12 9

7

5

6 10

3 11

Graphe des diviseurs

(15)

Repr´ esentation d’un graphe (1/4)

2

4 8

12 9

7

5

6 10

3 11

Matrice d’adjacence



 

 

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1 0 1 0 0 0 0 0 0 1 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0



 

 

(16)

Repr´ esentation d’un graphe (2/4)

Matrice d’adjacence M = (m_i,j)

o`u m_i,j = 1 si (v_i, v_j) est un arc du graphe, sinon m_i,j = 0.

Matrice sym´etrique pour un graphe non orient´e.

class Graphe {

boolean[ ][ ] m;

Graphe (int n) {

m = new boolean[n][n];

for (int i = 0; i < n; ++i) for (int j = 0; j < n; ++j)

m[x][y] = false;

}

static void ajouterArc (Graphe g, int x, int y) { g.m[x][y] = true; } }

Place m´emoire O(V ²)

(En fait l’initialisation de m est inutile, car c’est l’option par d´efaut en Java)

(17)

Repr´ esentation d’un graphe (3/4)

2

4 8

12 9

7

5

6 10

3 11

g.succ[0] = null;

g.succ[1] = null;

g.succ[2] = {4,6,8,12,10};

g.succ[3] = {6,9,12};

g.succ[4] = {8,12};

g.succ[5] = {10};

g.succ[6] = {12};

g.succ[7] = null;

g.succ[8] = null;

g.succ[9] = null;

g.succ[10] = null;

g.succ[11] = null;

g.succ[12] = null;

Remarque : {4,6,8,10,12} n’est malheureusement pas du Java l´egal, mais est ici une abr´eviation pour new Liste(4, new Liste(6, new Liste(8, new Liste(10, new Liste (12, null)))))

(18)

Repr´ esentation d’un graphe (4/4)

Tableau de listes de successeurs

(Repr´esentation creuse de la matrice d’adjacence)

class Graphe { Liste[ ] succ;

Graphe (int n) { succ = new Liste[n]; }

static void ajouterArc (Graphe g, int x, int y) { g.succ[x] = new Liste (y, g.succ[x]);

} }

Place m´emoire en O(V + E)

(19)

Entr´ ee textuelle d’un graphe

1`ere ligne : n = card(V ) ; lignes suivantes : arcs x_i ↔ y_i static Graphe lireGraphe () {

BufferedReader in = // idiosyncratie Java !

new BufferedReader(new InputStreamReader(System.in));

try {

String s = in.readLine(); int n = Integer.parseInt(s);

Graphe g = new Graphe (n);

while ((s = in.readLine()) != null) {

StringTokenizer st = new StringTokenizer(s);

int x = Integer.parseInt(st.nextToken());

int y = Integer.parseInt(st.nextToken());

if (0 <= x && x < n && 0 <= y && y < n) { ajouterArc(g, x, y);

ajouterArc(g, y, x);

} }

return g;

} catch (IOException e) {

System.err.println(e); System.exit(1); return null;

} }

(20)

Arbre de recouvrement (1/4)

2

0

4

1

8

6

12

2

9

4

7

9

5 8

6

5

10

7

3

11

10

Comment visiter tous les sommets sans boucler ?

(21)

Arbre de recouvrement (2/4)

2

0

4

1

8

6

12

2

9

4

7

9

5 8

6

5

10

7

3

11

10

⇒ Trouver une forˆet qui recouvre tous les sommets du graphe.

(22)

Arbre de recouvrement (3/4)

2

0

4

1

12

2

3 3

6

4

9

5

8

6

10

7

8 5

7

9

11

10

Vue de l’arbre de recouvrement avec des numéros correspondant à l’ordre préfixe sur l’arbre de recouvrement.

(23)

Arbre de recouvrement (4/4)

2

4

0

8

5

12

1

9

3

7

9

5 ⁸ 6

6

10

7

3

2

11

10

2

4

3

8

5

12

2

9

8

7

9

5 ⁷ 6

0

10

6

3

1

11

10

Un graphe peut avoir plusieurs arbres de recouvrement.

(24)

Parcours en profondeur (1/6)

final static int BLANC = 0, GRIS = 1, NOIR = 2;

static int[ ] couleur;

static void visiter (Graphe g) {

int n = g.succ.length; couleur = new int[n];

for (int x = 0; x < n; ++x) couleur[x] = BLANC;

for (int x = 0; x < n; ++x) if (couleur[x] == BLANC)

dfs(g, x);

}

static void dfs (Graphe g, int x) { couleur[x] = GRIS;

Pour tout y successeur de x dans G faire {

if (couleur[y] == BLANC) dfs(g, y);

}

couleur[x] = NOIR;

}

BLANC = non trait´e, NOIR = trait´e, GRIS = en cours de traitement. 1 2 3 4

(25)

Parcours en profondeur (2/6)

static int[ ] couleur;

dfs(g, x);

}

static void dfs (Graphe g, int x) { couleur[x] = GRIS;

for (Liste ls = g.succ[x]; ls != null; ls = ls.suivant) { int y = ls.val;

if (couleur[y] == BLANC) dfs(g, y);

}

couleur[x] = NOIR;

}

BLANC = non trait´e, NOIR = trait´e, GRIS = en cours de traitement. 1 2 3 4

(26)

Parcours en profondeur (3/6)

static int numOrdre;

static int[ ] num;

int n = g.succ.length; num = new int[n]; numOrdre = -1;

for (int x = 0; x < n; ++x) num[x] = -1;

for (int x = 0; x < n; ++x) if (num[x] == -1)

dfs(g, x);

}

static void dfs (Graphe g, int x) { num[x] = ++numOrdre;

if (num[y] == -1) dfs(g, y);

} }

Son temps est en O(V + E).

a démontré l’utilité de cette méthode. ¹ ² ³ ⁴

(27)

Parcours en profondeur (4/6)

static int numOrdre;

int n = g.succ.length; int[ ] num = new int[n]; numOrdre = -1;

for (int x = 0; x < n; ++x) num[x] = -1;

for (int x = 0; x < n; ++x) if (num[x] == -1)

dfs(g, x, num);

}

static void dfs (Graphe g, int x, int[ ] num) { num[x] = ++numOrdre;

if (num[y] == -1) dfs(g, y, num);

} }

Mieux car moins de variables globales.

Exercice 1

Supprimer la variable globale numOrdre.

(28)

Parcours en profondeur (5/6)

int n = g.succ.length; int[ ] couleur = new int[n];

dfs(g, x, couleur);

}

static void dfs (Graphe g, int x, int[ ] couleur) { couleur[x] = GRIS;

if (couleur[y] == BLANC) dfs(g, y, couleur);

}

couleur[x] = NOIR;

}

Pas de variables globales ⇒ modularit´e.

(29)

Parcours en profondeur (6/6)

Pile p = new Pile (n);

for (int x = 0; x < n; ++x) if (couleur[x] == BLANC) {

Pile.empiler(p, x); couleur[x] = GRIS;

dfs (g, p);

} }

static void dfs (Graphe g, Pile p) { while ( !p.vide() ) {

int x = Pile.depiler (p);

if (couleur[y] == BLANC) {

Pile.empiler(f, y); couleur[y] = GRIS;

}

couleur[x] = NOIR;

} } }

Itératif ⇒ plus compliqué que récursif.

(30)

Parcours en largeur (1/2)

2

0

4

1

8

2

12

5

9

8

7

9

5 ⁶ 6

3

10

4

3

7

11

10

Parcours selon la distance `a un sommet de d´epart.

(31)

Parcours en largeur (2/2)

FIFO f = new FIFO (n);

for (int x = 0; x < n; ++x) if (couleur[x] == BLANC) {

FIFO.ajouter(f, x); couleur[x] = GRIS;

bfs (g, f);

} }

static void bfs (Graphe g, FIFO f) { while ( !f.vide() ) {

int x = FIFO.supprimer (f);

if (couleur[y] == BLANC) {

FIFO.ajouter(f, y); couleur[y] = GRIS;

}

couleur[x] = NOIR;

} } }

Mˆemes programmes it´eratifs : DFS ≡ pile BFS ≡ file. ¹ ² ³ ⁴

(32)

Sortie de labyrinthe

On cherche un chemin de d à s. Êx´êcution

static Liste chemin (Graphe g, int d, int s, int[ ] couleur) { couleur[d] = GRIS;

if (d == s)

return new Liste (d, null);

for (Liste ls = g.succ[d]; ls != null; ls = ls.suivant) { int x = ls.val;

if (num[x] == BLANC) {

Liste r = chemin (g, x, s);

if (r != null)

return new Liste (d, r);

} }

return null;

}

Complexit´e en temps en O(V + E)

Exercice 2

D´eterminer le chemin le plus court vers la sortie.

Exercice 3

Imprimer tous les chemins vers la sortie.

(33)

Connexit´ e

Dans un graphe non-orient´e, une composante connexe est un ensemble maximal de sommets reli´es entre eux.

Exercice 4

Quelles sont les composantes connexes dans le graphe des diviseurs (non-orient´e).

Exercice 5

Ecrire le programme qui imprime les composantes connexes dans un graphe non-orient´e.

(34)

Exercices

Exercice 6

Ecrire dfs pour un graphe repr´esent´e par sa matrice d’adjacence.

Exercice 7

Montrer que la signification des couleurs n’est pas tout à fait la même entre le parcours en profondeur récursif et celui itératif avec pile. Montrer aussi que le parcours n’est pas le même non plus.

Exercice 8

Corriger le parcours itératif pour obtenir le même résultat que le parcours récursif. Faire de même avec les parcours produisant des numérotations des sommets.