Module 5 :

Algorithmes de graphes
 Plan du module
 Arbre couvrant minimum
 Algorithme de Prim
 Algorithmes de plus court chemin
 Algorithme de Dijkstra
 Algorithme de Floyd
 Problème 10034

19/7/2006 Algorithmes de graphes 2

 Arbre couvrant minimum
 Un arbre couvrant pour un graphe non-
orienté G est composé de tous les
sommets de G avec un sous-ensemble
des arêtes de G qui
 Relient les sommets; il existe un chemin
entre tous les sommets de l’arbre couvrant
 Forment un arbre sans racine, non
ordonné, sans cycle.

19/7/2006 Algorithmes de graphes 3

 Arbre couvrant minimum
 Un arbre couvrant minimum est un
arbre couvrant dont la somme des
étiquettes (valeurs attachées aux
arêtes) est minimale.

19/7/2006 Algorithmes de graphes 4

 Arbre couvrant minimum
9 b 9 b
a 2 6 a 2 6
d d
4 5 4 5
5 4 5 4

5 e 5 e
c c

19/7/2006 Algorithmes de graphes 5

 Arbre couvrant minimum
 Algorithme de Prim
 L’arbre est construit nœud après nœud
partant d’un nœud initial
 À chaque itération un nœud est ajouté à
l’arbre couvrant
 On ajoute toujours le nœud reliant l’arbre
avec l’arête de moindre poids

19/7/2006 Algorithmes de graphes 6

 Arbre couvrant minimum
9 9 b
b
a 2 6 a 2 6
d d
4 5 4 5
5 4 5 4

5 e 5 e
c c

A B C D E A B C D E
intree F F F F F intree T F F F F
distance ∞ ∞ ∞ ∞ ∞ distance 0 ∞ ∞ ∞ ∞
parent -1 -1 -1 -1 -1 parent -1 -1 -1 -1 -1

19/7/2006 Algorithmes de graphes 7

 Arbre couvrant minimum
9 b
a 2 6 Le nœud de départ est A.
d La table des distances et
4 5
5 4 des parents est mise à jour
5 e pour tous les nœuds
c adjacents à A.
On sélectionne parmi les
A B C D E nœuds restants celui relié
intree T F F F F par l’arête de plus petit
distance 0 9 5 2 ∞ poids.
parent -1 A A A -1

19/7/2006 Algorithmes de graphes 8

 Arbre couvrant minimum
9 b
a 2 6 Le nœud de départ est D.
d La table des distances et
4 5
5 4 des parents est mise à jour
5 e pour tous les nœuds
c adjacents à D pas encore
dans l’arbre.
A B C D E On sélectionne parmi les
intree T F F T F nœuds restants celui relié
distance 0 6 4 2 4 par l’arête de plus petit
parent -1 D D A D poids (ici C et E possibles).

19/7/2006 Algorithmes de graphes 9

 Arbre couvrant minimum
9 b
a 2 6 Le nœud de départ est C.
d La table des distances et
4 5
5 4 des parents est mise à jour
5 e pour tous les nœuds
c adjacents à C pas encore
dans l’arbre.
A B C D E On sélectionne parmi les
intree T F T T F nœuds restants celui relié
distance 0 6 4 2 4 par l’arête de plus petit
parent -1 D D A D poids.

19/7/2006 Algorithmes de graphes 10

 Arbre couvrant minimum
9 b
a 2 6 Le nœud de départ est E.
d La table des distances et
4 5
5 4 des parents est mise à jour
5 e pour tous les nœuds
c adjacents à E pas encore
dans l’arbre.
A B C D E On sélectionne parmi les
intree T F T T T nœuds restants celui relié
distance 0 5 4 2 4 par l’arête de plus petit
parent -1 E D A D poids.

19/7/2006 Algorithmes de graphes 11

 Arbre couvrant minimum
9 Plus rien ne change.
b
a 2 6 La table parent nous fournit
d l’arbre de couvrant minimum!
4 5
5 4

5 e 9 b
c
a 2 6
d
A B C D E 4 5
5 4
intree T T T T T
distance 0 5 4 2 4
5 e
c
parent -1 E D A D

19/7/2006 Algorithmes de graphes 12

 Arbre couvrant minimum
 FOR i := 0 TO g.nvertices-1 DO  v := start;
 BEGIN  dist := MAXINT;
 intree[i] := false; distance[i] := MAXINT;  FOR i := 0 TO g.nvertices-1 DO
 parent[i] := -1  BEGIN
 END;  IF (NOT intree[i]) AND (dist > distance[i])
 distance[start] := 0; v := start;  THEN BEGIN
 WHILE NOT intree[v] DO  dist := distance[i];
 BEGIN  v := i
 intree[v] := true;  END
 FOR i := 0 TO g.degree[v]-1 DO  END
 BEGIN
 w := g.edges[v][i].v;
 weight := g.edges[v][i].weight;
 IF (distance[w] > weight) AND NOT intree[w]
 THEN BEGIN
 distance[w] := weight; parent[w] := v
 END
 END;


19/7/2006 Algorithmes de graphes 13

 Algorithmes de plus court chemin
 Soit un graphe orienté ou non ayant des
étiquettes sur les arêtes pour
représenter leur « longueur ».
 On veut connaître la « distance »
minimale entre deux sommets.
 En général, la distance minimale d’un
sommet u au sommet v est la distance
minimum de tous les chemins de u à v.

19/7/2006 Algorithmes de graphes 14

 Algorithme de Dijkstra
 C’est l’algorithme de choix pour trouver
le chemin de distance minimum entre
deux nœuds d’un graphe.
 Cet algorithme calcule le plus court
chemin entre un nœud donné et tous
les autres d’un graphe.
 Ne fonctionne que sur des graphes
sans arêtes négatives.

19/7/2006 Algorithmes de graphes 15

 Algorithme de Dijkstra
 L’idée de base est très semblable à
l’algorithme de Prim.
 À chaque itération, on ajoute un nœud à
l’arbre de nœuds pour lequel nous
connaissons le plus court chemin
depuis la source s.

19/7/2006 Algorithmes de graphes 16

 Algorithme de Dijkstra
 Mais dans le problème du plus court
chemin :
 nous ajoutons un nœud qui est le plus
proche en distance de la source s
 Cette distance est fonction du poids de la
nouvelle arête et de la distance depuis la
source s de l’arbre de nœuds auquel
l’arête est adjacente.

19/7/2006 Algorithmes de graphes 17

 Algorithme de Dijkstra
u v
1

8
10
9

s 0 2 3 4 6

7
5
8

2 8
x y
19/7/2006 Algorithmes de graphes 18
 Algorithme de Dijkstra
u v
1 (s,x) est le plus
10 court chemin

8
utilisant une seule
10 arête.
9
C’est aussi le
plus court chemin
s 0 2 3 4 6 de s à x.

7
5
5
8
2
x y
19/7/2006 Algorithmes de graphes 19
 Algorithme de Dijkstra
u v
1
8 14

10
9

s 0 2 3 4 6

7
5
5 7
2
x y
19/7/2006 Algorithmes de graphes 20
 Algorithme de Dijkstra
u v
1
8 13

10
9

s 0 2 3 4 6

7
5
5 7
2
x y
19/7/2006 Algorithmes de graphes 21
 Algorithme de Dijkstra
u v
1
8 9

10
9

s 0 2 3 4 6

7
5
5 7
2
x y
19/7/2006 Algorithmes de graphes 22
 Algorithme de Dijkstra
u v
1
8 9

10
9

s 0 2 3 4 6

7
5
5 7
2
x y
19/7/2006 Algorithmes de graphes 23
 Algorithme de Dijkstra
BEGIN v := 0;
FOR i := 0 TO g.nvertices-1 DO dist := MAXINT;
BEGIN FOR i := 0 TO g.nvertices-1 DO
intree[i] := false; distance[i] := inf; parent[i] := -1 BEGIN
END; IF (NOT intree[i]) AND (dist > distance[i])
distance[start] := 0; THEN BEGIN
v := start; dist := distance[i];
WHILE NOT intree[v] DO v := i
BEGIN END
intree[v] := true; END
FOR i := 0 TO g.degree[v]-1 DO END;
BEGIN print_shortest_paths(g,0)
w := g.edges[v][i].v; END;
weight := g.edges[v][i].weight;
IF (distance[w] > distance[v]+weight) AND NOT intree[w]
THEN BEGIN
distance[w] := distance[v]+weight;
parent[w] := v
END
END;

19/7/2006 Algorithmes de graphes 24

 Algorithme de Floyd
 Trouver tous les plus courts chemins
entre toutes les paires de nœuds d’un
graphe.
 Le graphe peut contenir des arêtes
négatives, mais pas de cycle à coût
négatif

19/7/2006 Algorithmes de graphes 25

 Algorithme de Floyd
 Représentation du graphe :
 Une matrice de poids
 W(i,j)=0 si i=j
 W(i,j)= s’il n’y a pas d’arête entre i et j
 W(i,j) = “poids de l’arête”

19/7/2006 Algorithmes de graphes 26

 Algorithme de Floyd
1
3 v1 v2
9 1 2 3 4 5
5 1 2 3
v5 1 0 1  1 5
3
v4 2 v3 2 9 0 3 2 
4 3   0 4 
4   2 0 3
5 3    0

19/7/2006 Algorithmes de graphes 27

 Algorithme de Floyd
 Comment définir la distance la plus
courte di,j en termes de problèmes
plus “petits”?
 Une façon de faire consiste à se
limiter à des chemins n’incluant que
des nœuds d’un sous-ensemble
restreint.

19/7/2006 Algorithmes de graphes 28

 Algorithme de Floyd
 Initialement, ce sous-ensemble est
vide.
 Ensuite il est augmenté
progressivement, un nœud à la fois,
jusqu’à ce qu’il contienne tous les
nœuds du graphe.

19/7/2006 Algorithmes de graphes 29

 Algorithme de Floyd
 Soit D(k)[i,j]=poids du plus court
chemin de vi à vj n’utilisant que les
nœuds {v1,v2,…,vk} comme nœuds
intermédiaires dans le chemin
 D(0)=W
 D(n)=D c’est la matrice finale
 Comment calculer D(k) depuis D(k-1) ?

19/7/2006 Algorithmes de graphes 30

 Algorithme de Floyd
Cas 1: Un plus court chemin de vi à vj limité aux nœuds {v1,v2,…,vk} comme
nœuds intermédiaires n’utilise pas vk. Alors D(k)[i,j]= D(k-1)[i,j].
Cas 2: Un plus court chemin de vi à vj limité aux nœuds {v1,v2,…,vk} comme
nœuds intermédiaires utilise vk. Alors D(k)[i,j]= D(k-1)[i,k]+ D(k-1)[k,j].

Plus court chemin utilisant les nœuds {V1, . . . Vk }

Vk

Vj
Vi

Plus court chemin utilisant les nœuds { V1, . . . Vk -1 }

19/7/2006 Algorithmes de graphes 31

 Algorithme de Floyd
 Comme
D(k)[i,j]= D(k-1)[i,j] or
D(k)[i,j]= D(k-1)[i,k]+ D(k-1)[k,j].
On obtient:
D(k)[i,j]= min{ D(k-1)[i,j], D(k-1)[i,k]+ D(k-1)[k,j] }

Plus court chemin utilisant les nœuds

Vk
{V1, . . . Vk }

Vj
Vi

Plus court chemin utilisant les nœuds { V1, . . . Vk -1 }

19/7/2006 Algorithmes de graphes 32

 Algorithme de Floyd
1 2 3
1 0 4 5
W= D0 =
1 5 2 2 0 
3  -3 0
4 2 3
1 2 3
-3 1 0 0 0
2
P= 2 0 0 0
3 0 0 0

19/7/2006 Algorithmes de graphes 33

 Algorithme de Floyd
1 2 3 K=1
1 0 4 5 Le nœud 1 peut être nœud
D1 = intermédiaire.
2 2 0 7
3  -3 0
D1[2,3] = min( D0[2,3], D0[2,1]+D0[1,3] )
= min (, 7)
1 2 3 =7
1 0 0 0
D1[3,2] = min( D0[3,2], D0[3,1]+D0[1,2] )
P= 2 0 0 1 = min (-3,)
= -3
3 0 0 0

19/7/2006 Algorithmes de graphes 34

 Algorithme de Floyd
1 2 3 K=2
1 0 4 5 Les nœuds 1 et 2 peuvent
D2 = être nœuds intermédiaires.
2 2 0 7
3 -1 -3 0
D2[1,3] = min( D1[1,3], D1[1,2]+D1[2,3] )
1 2 3 = min (5, 4+7)
=5
1 0 0 0 D2[3,1] = min( D1[3,1], D1[3,2]+D1[2,1] )
P= 2 0 0 1 = min (, -3+2)
= -1
3 2 0 0

19/7/2006 Algorithmes de graphes 35

 Algorithme de Floyd
1 2 3 K=3
1 0 2 5 Les nœuds 1, 2, 3 peuvent
D3 = être nœuds intermédiaires.
2 2 0 7
3 -1 -3 0 D3[1,2] = min(D2[1,2], D2[1,3]+D2[3,2] )
= min (4, 5+(-3))
=2
1 2 3
1 0 3 0
P= 2 0 0 1 D3[2,1] = min(D2[2,1], D2[2,3]+D2[3,1] )
= min (2, 7+ (-1))
3 2 0 0 =2

19/7/2006 Algorithmes de graphes 36

 Algorithme de Floyd

1. D  W // initialiser D avec les poids des arêtes

2. P  0 // initialiser P à 0
3. for k  1 to n
4. do for i  1 to n
5. do for j  1 to n
6. if (D[ i, j ] > D[ i, k ] + D[ k, j ] )
7. then D[ i, j ]  D[ i, k ] + D[ k, j ]
8. P[ i, j ]  k;

19/7/2006 Algorithmes de graphes 37

 Algorithme de Floyd
 Pourquoi peut-on travailler sur une
même matrice ?
 D[i,j] ne dépend que des éléments de la
kième ligne et kième colonne de la matrice.
 La kième ligne et kième colonne de la
matrice restent inchangées lorsqu’on
calcule Dk

19/7/2006 Algorithmes de graphes 38

 Algorithme de Floyd
 Les éléments de la diagonale principale
restent à 0 car :
 D(k)[ j,j ] = min{ D(k-1)[ j,j ] , D(k-1)[ j,k ] + D(k-1)[ k,j ] }
= min{ 0, D(k-1)[ j,k ] + D(k-1)[ k,j ] }
=0

19/7/2006 Algorithmes de graphes 39

 Algorithme de Floyd
 La kième colonne de Dk est égale à la
kième colonne de Dk-1 :
 Pour tout i
 D(k)[i,k] = min{ D(k-1)[i,k], D(k-1)[i,k]+ D(k-1)[k,k] }
= min { D(k-1)[i,k], D(k-1)[i,k]+0 }
= D(k-1)[i,k]

19/7/2006 Algorithmes de graphes 40

 Algorithme de Floyd
 La kième ligne de Dk est égale à la
kième ligne de Dk-1 :
 Pour tout i
 D(k)[k,j] = min{ D(k-1)[k,j], D(k-1)[k,k]+ D(k-1)[k,j] }
= min{ D(k-1)[ k,j ], 0+D(k-1)[k,j ] }
= D(k-1)[ k,j ]

19/7/2006 Algorithmes de graphes 41

 Algorithme de Floyd
 FOR k := 1 TO g.nvertices DO
 FOR i := 1 TO g.nvertices DO
 FOR j := 1 TO g.nvertices DO
 BEGIN
 through_k := g.weight[i,k]+g.weight[k,j];
 IF through_k < g.weight[i,j]
 THEN BEGIN
 g.weight[i,j] := through_k;
 p[i,j] := k
 END
 END

19/7/2006 Algorithmes de graphes 42

 Problème 10034
 In an episode of the Dick Van Dyke show, little Richie
connects the freckles on his Dad's back to form a
picture of the Liberty Bell. Alas, one of the freckles
turns out to be a scar, so his Ripley's engagement
falls through. Consider Dick's back to be a plane with
freckles at various (x,y) locations. Your job is to tell
Richie how to connect the dots so as to minimize the
amount of ink used. Richie connects the dots by
drawing straight lines between pairs, possibly lifting
the pen between lines. When Richie is done there
must be a sequence of connected lines from any
freckle to any other freckle.

19/7/2006 Algorithmes de graphes 43

 Problème 10034
 Input
 The input begins with a single positive integer on a line by
itself indicating the number of the cases following, each of
them as described below. This line is followed by a blank line,
and there is also a blank line between two consecutive inputs.
 The first line contains 0 < n <= 100, the number of freckles on
Dick's back. For each freckle, a line follows; each following line
contains two real numbers indicating the (x,y) coordinates of the
freckle.
 Output
 For each test case, the output must follow the description
below. The outputs of two consecutive cases will be separated
by a blank line.
 Your program prints a single real number to two decimal places: the
minimum total length of ink lines that can connect all the freckles.

19/7/2006 Algorithmes de graphes 44

 Problème 10034
Sample Input

3
1.0 1.0
2.0 2.0
2.0 4.0

Sample Output

3.41

19/7/2006 Algorithmes de graphes 45