Algo Polycopie2011

Algorithmique
Amin Shokrollahi
Semestre dAutomne 2010-2011
Contents
0 Introduction 1
0.1 Quest ce quun algorithme? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
0.2 Exemples dalgorithmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
0.2.1 Somme dentiers positifs . . . . . . . . . . . . . . . . . . . . . . . . . . 1
0.2.2 Probl` eme de Localisation . . . . . . . . . . . . . . . . . . . . . . . . . . 3
0.2.3 Monnaie Optimale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
0.3 Th eorie des ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
0.3.1 Rappels de notations de logique . . . . . . . . . . . . . . . . . . . . . . 6
0.3.2 Rappels de notations de th eorie des ensembles . . . . . . . . . . . . . . 7
0.3.3 Ensembles des parties, Ensembles des mots . . . . . . . . . . . . . . . . 9
0.3.4 Ensembles standards . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
0.4 Relations et Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
0.5 Sp ecication dun Probl` eme . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
0.6 Du Probl` eme ` a lalgorithme et son impl ementation . . . . . . . . . . . . . . . . 14
1 Induction 15
1.1 Ce que cest et ` a quoi ca sert . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.2 Techniques dinduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.2.1 Induction simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.2.2 Induction descendante . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.2.3 Induction Forte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.3 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
1.3.1 La formule dEuler pour les arbres . . . . . . . . . . . . . . . . . . . . . 22
1.3.2 Ensemble Ind ependant de lHypercube . . . . . . . . . . . . . . . . . . 24
1.3.3 Le Lemme de Schwartz-Zippel . . . . . . . . . . . . . . . . . . . . . . . 28
2 Analyse dAlgorithmes 30
2.1 Pourquoi analyser des Algorithmes? . . . . . . . . . . . . . . . . . . . . . . . . 30
2.2 Exemple: Multiplication de polyn omes . . . . . . . . . . . . . . . . . . . . . . . 30
2.3 Exemple: Multiplication de matrices . . . . . . . . . . . . . . . . . . . . . . . . 32
2.4 La notation O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.5 Lalgorithme de Karatsuba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.6 Lalgorithme de Strassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
i
Algorithmique - Semestre dAutomne 2010/2011
2.7 Relations de R ecurrence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
2.8 Remarques Finales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3 Structures de donn ees el ementaires 46
3.1 Ensembles dynamiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.2 Structures des donn ees dynamiques el ementaires . . . . . . . . . . . . . . . . . 47
3.2.1 Stack (ou pile) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.2.2 Files dattente (Queues) . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.2.3 Listes li ees (Linked lists) . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.3 Graphes et Arbres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.3.1 Repr esenter des graphes . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.3.2 Arbres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
3.3.3 Repr esentation darbres . . . . . . . . . . . . . . . . . . . . . . . . . . 63
3.3.4 Parcourir des arbres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
3.3.5 R esum e de la section 3.3 . . . . . . . . . . . . . . . . . . . . . . . . . . 68
3.4 Structures de donn ees pour des algorithmes de recherche . . . . . . . . . . . . . 69
3.4.1 Arbres binaires de recherche . . . . . . . . . . . . . . . . . . . . . . . . 69
3.4.2 Arbres bicolores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
3.4.3 Arbres AVL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
3.5 Le Hachage (Hashing) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
4 Construction dalgorithmes par induction 90
4.1 La m ethode de Horner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
4.2 Elimination de Gauss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
4.3 Les algorithmes diviser-pour-r egner . . . . . . . . . . . . . . . . . . . . . . . . 95
4.3.1 Le paradigme DPR g en eral . . . . . . . . . . . . . . . . . . . . . . . . . 95
4.3.2 Lalgorithme de Karatsuba . . . . . . . . . . . . . . . . . . . . . . . . . 96
4.3.3 Recherche binaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
4.3.4 MergeSort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
4.3.5 La paire la plus proche . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
4.3.6 Carrelage de formes L . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
4.4 Programmation dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
4.4.1 Multiplication de plusieurs matrices . . . . . . . . . . . . . . . . . . . . 104
4.4.2 Le probl` eme LCS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
4.4.3 Le plus-court-chemin-pour-toute-paire (Floyd-Warshall) . . . . . . . . . 112
4.4.4 Le Probl` eme 0/1-Knapsack (Sac-` a-dos 0/1) . . . . . . . . . . . . . . . . 115
4.5 Un algorithme plus rapide pour le probl` eme LCS . . . . . . . . . . . . . . . . . 119
5 Algorithmes gloutons 126
5.1 Exemple: horaires de salles de cours . . . . . . . . . . . . . . . . . . . . . . . . 126
5.2

El ements dune strat egie gloutonne . . . . . . . . . . . . . . . . . . . . . . . . . 127
5.3 Glouton compar e ` a la programmation dynamique: Le probl` eme du sac ` a dos . . . 128
5.4 Codes de Huffman . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
ii
5.4.1 Codes represent es par des arbres binaires . . . . . . . . . . . . . . . . . 132
5.4.2 Le codage de Huffman . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
5.4.3 Impl ementation de lalgorithme de codage de Huffman . . . . . . . . . . 133
5.4.4 Optimalit e de lalgorithme de codage de Huffman . . . . . . . . . . . . . 137
6 Algorithmes de tri 139
6.1 Algorithmes el ementaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
6.1.1 Selection Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
6.1.2 Insertion Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
6.1.3 Shell Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
6.1.4 Bubble Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
6.2 Quicksort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
6.2.1 Variantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
6.3 Heap Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
6.3.1 Sifting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
6.3.2 Cr eation dun heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
6.3.3 Lalgorithme HEAPSORT . . . . . . . . . . . . . . . . . . . . . . . . . . 159
6.3.4 Priority Queues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
7 Algorithmes de graphes 163
7.1 Parcourir des graphes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
7.2 Lalgorithme Depth First Search (DFS) . . . . . . . . . . . . . . . . . . . . . . . 165
7.3 Lalgorithme Breadth First Search (BFS) . . . . . . . . . . . . . . . . . . . . . . 165
7.4 Tri Topologique (Topological Sorting) . . . . . . . . . . . . . . . . . . . . . . . 166
7.5 Chemins les plus courts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
7.6 Lalgorithme de Moore-Bellman-Ford . . . . . . . . . . . . . . . . . . . . . . . 175
7.7 Flux de r eseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
7.8 Application: Maximum Bipartite Matching . . . . . . . . . . . . . . . . . . . . 187
7.9 Arbres couvrants minimaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
7.9.1 Lalgorithme de Kruskal . . . . . . . . . . . . . . . . . . . . . . . . . . 191
7.9.2 La structure Union Find . . . . . . . . . . . . . . . . . . . . . . . . . 193
7.9.3 Version nale de lalgorithme de Kruskal . . . . . . . . . . . . . . . . . 195
7.9.4 Lalgorithme de Prim . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
7.10 D etecter des cycles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
7.10.1 D etecter des cycles n egatifs . . . . . . . . . . . . . . . . . . . . . . . . 199
7.10.2 Lalgorithme de Karp pour trouver des cycles avec poids moyen minimal 200
8 Les probl` emes NP-complets 203
8.1 La classe P . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
8.2 R eduction polynomiale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
8.3 La classe NP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
8.4 NP-Compl etude . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
8.5 Probl` emes de Satisabilit e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
iii
8.6 Quelques probl` emes de graphe NP-Complets . . . . . . . . . . . . . . . . . . . 209
8.7 Quelques autres problemes de graphe
NP-complets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
8.8 Probl` emes de th eorie des ensembles . . . . . . . . . . . . . . . . . . . . . . . . 212
1
0
Introduction
0.1 QUEST CE QUUN ALGORITHME?
Informellement, on peut d enir un algorithme comme suit:
Un algorithme est une suite d etapes dont le but est de r esoudre un probl` eme
ou daccomplir une t ache.
Les algorithmes sont utilis es partout. Par exemple, une recette pour votre plat pr ef er e peut
etre un algorithme. Nous rafnerons le concept dun algorithme en etudiant des exemples.
0.2 EXEMPLES DALGORITHMES
0.2.1 Somme dentiers positifs
Probl` eme: Calculer la somme des n premiers entiers positifs
Input: n N := 1, 2, 3, . . .
Output: S(n) := 1 + 2 + 3 +. . . +n =
n
k=1
k
Par exemple, si n = 10, lalgorithme retourne 55.
Une approche nave serait de d enir une variable s initialis ee ` a z ero, puis dy ajouter un par
un les nombres de 1 ` a n. Le code correspondant s ecrit:
1
Algorithme 1 M ethode nave de sommation
Input: Un entier positif n N.
Output: La somme s :=
n
k=1
k.
s 0
for i = 1 to n do
s s +i
end for
return s
Une meilleure m ethode a et e d ecouverte par le math ematicien allemand Carl Friedrich Gau
` a l age de 5 ans. Son instituteur, pour le punir, lui demanda de calculer la somme des entiers
de 1 ` a 100. Le jeune Gau annonca le r esultat tr` es peu de temps apr` es, car il avait r ealis e quon
pouvait ajouter les termes deux par deux en partant des c ot es oppos es de la liste, et que les termes
interm ediaires ainsi obtenus etaient tous identiques: 1+100 = 101, 2+99 = 101, . . . , 50+51 =
101. On obtient ainsi 50 termes, le r esultat est donc 50 101 = 5050.
Cette m ethode peut etre g en eralis ee ` a tout n pair. On a:
n
2
termes
_
_
1 + n = n + 1
2 + n 1 = n + 1
3 + n 2 = n + 1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
n
2
1 +
n
2
+ 2 = n + 1
n
2
+
n
2
+ 1 = n + 1
Donc,
S(n) =
n(n + 1)
2
.
Limpl ementation de la m ethode de Gau est triviale; Il suft d ecrire la formule ci-dessus:
Algorithme 2 M ethode de sommation de Gau
Input: Un entier positif n N.
Output: La somme s :=
n
k=1
k.
return
n(n+1)
2
Nous avons d eclar e que la m ethode de Gau etait meilleure que notre m ethode originale.
Mais que veut dire meilleure? Nous pouvons donner un sens pr ecis a ce terme: nous voulions
dire quen utilisant la m ethode de Gau, la somme pouvait etre calcul ee de facon plus efcace.
Ceci peut etre montr e formellement en comparant le nombre dop erations arithm etiques dont a
besoin chaque algorithme pour parvenir au r esultat.
La premi` ere m ethode utilise n additions du compteur s. (Nous ignorons les additions de i).
La deuxi` eme m ethode utilise 3 op erations arithm etiques (une addition, une multiplication et une
division). La m ethode de Gau est donc plus performante pour n > 3.
2
Il nous manque toujours:
Une d emonstration que la formule de Gau est juste. (R ecurrence!)
Une notion de performance et des m ethodes pour analyser nos algorithmes.
Une sp ecication formelle du probl` eme.
0.2.2 Problème de Localisation
Probl` eme: Probl` eme de localisation
Input: Des entiers a
0
< a
1
< < a
n1
, et x Z
Output: Trouver un indice i tel que a
i
= x, si un tel i existe
Exemple: Supposons que les entiers soient 1, 3, 8, 11, 39, 41; Si x = 39, loutput de lalgorithme
serait 4, alors que si x = 26 il ny aurait pas de r eponse.
Voici une premi` ere solution au probl` eme:
Algorithme 3 Recherche lin eaire
i 0
while a
i
,= x and i < n do
i i + 1
end while
if i = n then
return ERROR
else
return i
end if
Quelle est lefcacit e de cette solution? Comme avant, nous comptons le nombre dop erations
arithm etiques que doit r ealiser lalgorithme. Nous ignorons de nouveau les op erations qui ne
concernent que le compteur i. Les op erations restantes sont donc les comparaisons a
i
,= x. Cet
algorithme effectue n comparaisons dans le pire des cas (ici le pire des cas se produit quand x
nest pas dans la liste ou quand x est le dernier el ement, x = a
n1
).
Peut-on faire mieux? Oui, car on peut utiliser le fait que les a
i
sont ordonn es. Cest ce que
fait lalgorithme suivant, appel e Recherche Binaire (Binary Search):
3
Algorithme 4 Recherche binaire
i 0, j n
while j i > 1 do

_
ji
2
_
+i
if x < a
then
j
else
i
end if
end while
if x ,= a
i
then
return ERROR
else
return i
end if
Supposons que k soit la solution recherch ee, i.e., a
k
= x. Par convention, nous posons
a
n
= . Au d ebut de chaque it eration de la boucle while, on a
a
i
a
k
< a
j
. (1)
En effet, avant la premi` ere it eration, (1) est clairement vraie. Dans toutes les it erations qui
suivent, nous modions i et j de telle facon ` a ce quelle reste vraie. Puisque les a sont ordonn es,
on d eduit de (1) que
i k < j.
A chaque it eration lintervalle [i, j[ est coup e en deux, puisque est choisi tel quil soit au milieu
de i et j. On nira donc forc ement par trouver k.
La recherche binaire utilise au plus log
2
(n) comparaisons (pourquoi ?), et cet algorithme
est donc beaucoup plus efcace que le premier algorithme. (Remarque: log
2
(n) est beaucoup
plus petit que n quand n est grand. Par exemple, si n = 100, log
2
(n) vaut environ 6.64, et si
n = 1024, log
2
(n) vaut 10).
Outils de construction de lalgorithme
Outils danalyse de lalgorithme
Structures de donn ees (Data structures) pour r ealiser lalgorithme
4
0.2.3 Monnaie Optimale
Probl` eme: Monnaie optimale
Input: Une collection C = 1, 2, 5, 10, 20, 50, 100 de valeurs de pi` eces
de monnaie, et un entier x
Output: Une suite nie de pi` eces, contenant aussi peu de pi` eces que pos-
sible, dont la somme des valeurs vaut x
Exemple: Si x = 325, alors
c
0
= c
1
= c
2
= 100, c
3
= 20, c
4
= 5.
Nous pouvons donc obtenir le r esultat demand e en utilisant 5 pi` eces.
Voici lalgorithme le plus simple qui vienne ` a lesprit, appel e Algorithme Glouton (Greedy
Algorithm):
Algorithme 5 Algorithme Glouton
v 0 et t 0
while v < x do
Trouver le plus grand c C tel que c +v x
c
t
c
v v +c
t t + 1
end while
return (c
0
, c
1
, . . . , c
t1
)
Cet algorithme retourne-t-il une suite de pi` eces dont la somme des valeurs vaut x? Si oui, le
nombre de pi` eces est-il minimal?
Une preuve que lalgorithme est juste
Sp ecication du probl` eme
Analyse
Solution optimale
Structures de donn ees (Data structures)
5
Principes de construction (greedy algorithms)
Le premier pas vers ces objectifs est davoir une mani` ere rigoureuse de d ecrire ce que lalgorithme
doit accomplir, cest-` a-dire une sp ecication formelle du probl` eme. Ceci n ecessite quelques
concepts math ematiques (ensembles, relations, fonctions, . . . ) que nous d ecrirons dans les
prochaines sections.
0.3 TH
EORIE DES ENSEMBLES

Nous supposons que la notion densemble est connue. En g en eral, nous noterons les ensembles
par des lettres majuscules A, B, etc. Les mots famille et collection seront pour nous des
synonymes de ensemble.
0.3.1 Rappels de notations de logique
Rappelons les symboles suivants:
pour tout il existe
et ou
= implique appartient ` a
Exemple: Lexpression
x A : x ,= y = x > y x < y,
est lue comme suit:
Pour tout x appartenant ` a A, si x est distinct de y, alors x est strictement plus
grand que y ou x est strictement plus petit que y.
Rappelons aussi que les versions barr ees ,, / , etc... d enotent les oppos es des symboles
correspondants (cest-` a-dire, x / A veut dire que x nappartient pas ` a A).
Remarque:
Le symbole est un A tourn e; en anglais on dit for All, en allemand f ur Alle.
Le symbole est un E tourn e; on dit il Existe.
Le symbole rappelle ` a un E, comme

El ement; x A peut aussi etre lu x el ement de
A.
6
0.3.2 Rappels de notations de theorie des ensembles
Un ensemble A peut etre sp eci e de nombreuses facons; si A est ni, contenant (exactement) les
el ements a
1
, a
2
, . . . , a
n
, il suft de les enum erer, i.e., d ecrire
A = a
1
, . . . , a
n
.
Si A est le sous-ensemble dun certain ensemble B, et si A est form e de tous les membres x B
v eriant une certaine propri et e P(x), nous pouvons ecrire
A = x B [ P(x).
Exemple: Si B est lensemble de tous les nombres premiers, alors nous pouvons ecrire
2, 3, 5, 7, 11, 13, 17, 19 = x B [ x < 20,
o` u l egalit e = ci-dessus signie que lensemble ` a gauche est form e dexactement les m emes
el ements que celui ` a droite. (Voir ci-dessous pour une d enition formelle d egalit e entre ensem-
bles.)
Rappelons les notations suivantes:
A B A est sous-ensemble de B.
A B A est sous-ensemble strict de B.
A = B A et B sont egaux.
Comme avant, les versions barr ees de ces symboles signient leur oppos e (i.e. A ,= B: A et B
sont diff erents). Nous pouvons utiliser les notations de logique ci-dessus pour d enir pr ecis ement
ces symboles:
D enition. Pour des ensembles A et B, nous d enissons , =, entre ensembles comme suit:
A B si et seulement si x : x A = x B.
A = B si et seulement si A B et B A.
A B si et seulement si A B et A ,= B.
Nous disposons de quelques op erateurs sur les ensembles:
A B d enote lunion de A et B.
A B d enote lintersection de A et B.
A B d enote la diff erence de A et B.
AB d enote le produit cart esien de A et de B.
7
D enition. Lunion, lintersection, la diff erence et le produit cart esien densembles peuvent etre
d enis comme suit:
Lunion de deux ensembles A et B est lensemble
A B := x [ x A x B.
Plus g en eralement, si F est un ensemble de sous-ensembles dun ensemble X, lunion de
tous les membres de F est d enie comme suit:
_
AF
A := x X [ A F : x A
Lintersection de deux ensembles A et B est lensemble
A B := x [ x A x B.
De mani` ere plus g en erale, pour une famille F de sous-ensembles de X, lintersection de
tous les membres de X est lensemble
AF
A := x X [ A F : x A.
La diff erence de A et B est lensemble
A B := x A [ x / B.
La diff erence symm etrique de A et B est lensemble
AB = (A B) (B A).
Le produit cart esien A B est lensemble de tous les couples (a, b), o` u a A et b B.
(Deux el ements (a, b), (a
, b
) AB sont egaux si et seulement si a = a
et b = b
). Pour
des ensembles A
1
, . . . , A
n
, le produit cart esien A
1
A
n
est lensemble de n-tuples
(a
1
, . . . , a
n
) o` u a
1
A
1
, . . . , a
n
A
n
.
Le n-` eme produit cart esien de A est lensemble
A
n
:= A A
. .
n fois
.
Remarque: Les op erateurs et , respectivement et , ne sont pas seulement supercielle-
ment similaires. En fait, la d enition de fait appel ` a et celle de ` a .
8
D enition. A tout ensemble A nous pouvons associer une quantit e appel ee sa cardinalit e (ou
simplement taille). Nous d enotons [A[ la cardinalit e de A, d enie comme etant
[A[ :=
_
n si A contient exactement n el ements,
si le nombre d el ements de A nest pas ni.
Pour dire que A est ni, nous ecrivons souvent [A[ < . Il nexiste quun seul ensemble
de cardinalit e nulle, qui est lensemble vide , caract eris e par le fait quaucun el ement nest
contenu dans .
D enition. Les ensembles A et B sont disjoints si
A B = ,
i.e., si A et B nont aucun el ement en commun.
Soit X un ensemble et F une famille de sous-ensembles disjoints de X. La r eunion disjointe
des membres de F est not ee
_
AF
A.
Il ne sagit de rien autre que de lunion usuelle. Mais parfois, on parle de r eunion disjointe et
on ecrit au lieu se pour souligner le fait que les ensembles sont disjoints. (Par exemple, de
mani` ere g en erale, on a
_
AF
A
AF
[A[,
ce qui nest pas toujours vrai pour lunion usuelle.)
0.3.3 Ensembles des parties, Ensembles des mots
D enition. Lensemble des parties dun ensemble X est d eni comme etant lensemble de tous
les sous-ensembles de X. Lensemble des parties de X est not e Pot(X) ou encore 2
X
.
Lensemble des parties nies de X est d eni comme etant lensemble de tous les sous-
ensembles nis de X. Il est not e Pot
(X).
On voit que si X est ni, alors on a Pot(X) = Pot
(X).
Remarque: L ecriture 2
X
est due au fait que si X est ni, on a [2
X
[ = 2
|X|
. La notation Pot(X)
vient de lallemand: lensemble des parties sappelle die Potenzmenge en allemand.
9
Exemple: Si A = Ding, 3, Brr, alors
Pot(A) = , Ding, 3, Brr, Ding, 3, Ding, Brr, 3, Brr, Ding, 3, Brr.
D enition. Soit A un ensemble. Lensemble des mots sur A est lensemble
A
:=
_
n0
A
n
.
Lensemble des mots non-vides sur A est lensemble
A
+
:=
_
n1
A
n
.
On a donc A
= A
+
.
Exemple: Si A = a, b, c, d, . . . , z, alors A
contient, entre autres, les mots

(t, o, u, r), (m, a, i, s, o, n), (p, k, z, r, f, a), .
Tous ces mots sauf appartiennent aussi ` a A
+
.
0.3.4 Ensembles standards
Les ensembles suivants seront souvent utilis es par la suite:
N les nombres naturels
N
0
les entiers non n egatifs
Z les entiers
Q les nombres rationnels
R les nombres r eels
R
0
les nombres r eels non n egatifs
R
>0
les nombres r eels positifs
C les nombres complexes
Rappelons que
N = 1, 2, 3, . . . ..
N
0
= 0, 1, 2, 3, . . . ..
Z = . . . , 2, 1, 0, 1, 2, . . ..
Q =
a
b
[ a, b Z, b ,= 0.
On a N N
0
Z Q R C.
10
0.4 RELATIONS ET FONCTIONS
Dans toute cette partie, A et B seront des ensembles.
D enition. Une relation entre A et B est un sous ensemble R A B.
Si R AA, on dit que R est une relation sur A au lieu de une relation entre A et A.
Exemple: A = B = N,
R := (m, n) [ m, n N, m divise n
est la relation de divisibili e. On a donc (3, 12), (4, 4) R, mais (5, 9) / R.
Nous avons lhabitude de travailler avec des relations, mais en utilisant une notation diff erente.
Par exemple est une relation sur Z, mais il est plus pratique d ecrire a b que (a, b)
R
, o` u R
:= (m, n) [ m, n Z, m n.
D enition. La relation inverse de R est d enie par
R
1
:= (b, a) B A [ (a, b) R.
Exemple: La relation inverse de (R
dans lexemple ci-dessus) est la relation sup erieur ou

egal ` a .
D enition. Une relation R est dite sym etrique si R = R
1
.
Exemple: Si P est un ensemble dhommes, alors etre le fr` ere de est une relation sym etrique
sur P: Si David est le fr` ere de Georges, alors Georges est aussi le fr` ere de David.
D enition. Une fonction partielle est une relation F AB qui v erie
a A: [b B [ (a, b) F[ 1. (2)
Une fonction est une fonction partielle pour laquelle on a egalit e dans (2).
Si F est une fonction et (a, b) F, alors on ecrit b = F(a), et on dit que F envoie a sur b,
ou aussi que b est limage de a par F.
On utilise parfois la notation F : A B pour dire que F est une fonction de A vers B.
Lensemble de toutes les fonctions de A vers B est not e B
A
.
11
On remarque que si F est une fonction F : A B, alors pour chaque a A, il existe exacte-
ment un b B tel que b = F(a). Nous avons lhabitude de travailler avec des fonctions, mais
sans les consid erer comme des relations. On voit une fonction plut ot comme une transformation
` a laquelle on donne un el ement de A et qui nous retourne un el ement de B.
Exemple: La relation
F = (a, b) [ a, b R, b = a
2
est une fonction. La relation

R = (a, b) [ a, b R, b
2
= a
nest pas une fonction, car si a < 0, il ny a pas de b R tel que (a, b) R. En fait, R nest
m eme pas une fonction partielle, car si a > 0, il y a deux valeurs de b R pour lesquelles
(a, b) R. Cependant, la m eme relation d enie entre R
0
et R
0
est une fonction: il est facile
de v erier que
R
= (a, b) [ a, b R
0
, b
2
= a
a pour chaque a R
0
exactement une image b R
0
. R
est la fonction racine carr ee.

D enition. Une fonction F : A B est dite surjective si pour tout b B, il existe a A tel
que b = F(a).
Exemple: La fonction F = (a, b) [ a, b R, b = 2a + 1 est surjective, car pour tout
b R, il existe un a R dont limage par F est b, ` a savoir a = (b 1)/2. Par contre,
G = (a, b) [ a, b R, b = a
4
+ 1 nest pas surjective. En effet, pour b = 1 il ny a pas de
a R tel que F(a) = b.
D enition. Une fonction F est dite injective si F(a) = F(a
) implique que a = a
.
On remarque quune d enition equivalente de linjectivit e de F est a ,= a
= F(a) ,=
F(a
).
Exemple: La fonction F = (a, b) [ a, b R, b = a
3
est injective. En effet, si a
3
= b
3
alors on
a a = b. Par contre, G = (a, b) [ a, b R, b = a
2
nest pas injective car G(1) = 1 = G(1).
Si A = a
1
, . . . , a
m
est ni, alors il peut etre pratique dexprimer F : A B sous la forme
dun vecteur. On ecrit
(F(a
1
), . . . , F(a
m
)).
12
0.5 SP
ECIFICATION DUN PROBL

`
EME
D enition. Un probl` eme computationnel est sp eci e de facon abstraite par un triplet densembles
P = (I, O, R)
o` u I et O sont des ensembles non vides, et R I O est une relation. On appelle I lensemble
des inputs, O lensemble des outputs, et R la d ependance relationnelle (relational dependency).
Exemple: Notre premier exemple, le calcul de la somme des n premiers entiers positifs, peut
etre sp eci e comme suit:
I = N
O = N
R =
_
(n, m)
m =
n
k=1
k
_
I O.
Exemple: Le probl` eme de Monnaie Optimale a la sp ecication suivante:
I = Pot
(N) N
O = N
+
R =
_
((a
1
, . . . , a
n
; x), (c
1
, . . . , c
m
)) I O
i : c
i
a
1
, . . . , a
n

m
i=1
c
i
= x
(d
1
, . . . , d
m
) a
1
, . . . , a
n
+
:
m
i=1
d
i
= x = m
m
_
Rappelons que Pot
(N) est lensemble des sous-ensembles nis de N, et N

+
est lensemble
des mots non vides en N. (Voir 0.3)
Linput est constitu e dun ensemble de valeurs de pi` eces de monnaie A = a
1
, . . . , a
n

Pot
(N), et dun nombre naturel x N pour lequel nous voulons obtenir la monnaie optimale.
Loutput est une suite (c
1
, . . . , c
m
) A
m
de valeurs de pi` eces dont la somme vaut x, et telle
que m est minimal parmi toutes les suites qui ont cette propri et e.
Une sp ecication exacte dun probl` eme est d ej` a un pas majeur vers la construction et lanalyse
dun algorithme pour ce probl` eme. En pratique, une sp ecication exacte dun probl` eme est sou-
vent plus difcile ` a trouver quelle ne le parat.
13
0.6 DU PROBL
`
EME
`
A LALGORITHME ET SON IMPL
EMEN-
TATION
Les etapes typiques dans la construction dalgorithmes et dans leur impl ementation pratique sont
les suivantes:
1. Sp ecication formelle du probl` eme. Souvent, le probl` eme nous est donn e en prose
(francais, anglais, allemand, ...) et la t ache est de trouver une sp ecication exacte. Quel
est lensemble des inputs possibles, quel est lensemble des outputs possibles, et quelle est
la d ependance relationnelle entre les deux?
2. S eparation du probl` eme en morceaux plus petits et plus g erables. Souvent le probl` eme
est trop grand pour etre attaqu e dun seul coup. Il doit etre s epar e en sous-probl` emes plus
petits, qui doivent etre eux-m emes sp eci es. De plus, un m echanisme doit etre trouv e
pour recoller les solutions des sous-probl` emes an dobtenir une solution du probl` eme
original.
3. Construction dalgorithmes. Pour chaque sous-probl` eme, un algorithme doit etre con-
struit pour le r esoudre. Souvent en pratique lune des nombreuses techniques de construc-
tion dalgorithmes peut etre utilis ee ` a cette n. Cependant, dans certains cas, de nouveaux
algorithmes doivent etre constitu es. La construction doit etre motiv ee par des contraintes
defcacit e, et donc des m ethodes danalyse dalgorithmes doivent etre utilis ees. De plus,
tous les algorithmes doivent etre v eri es et prouv es.
4. Construction de structures de donn ees. Les structures de donn ees sont le lien entre
les algorithmes th eoriques et leur impl ementation pratique. Elles sont cruciales pour la
performance dun algorithme dans limpl ementation.
5. Impl ementation. Au bout de la route on trouve limpl ementation. Celle-ci se classe dans
le domaine du g enie logiciel, qui ne nous concernera pas dans ce cours.
14
1
Induction
1.1 CE QUE CEST ET
`
A QUOI CA SERT
Linduction math ematique est une m ethode pour prouver des afrmations concernant des ensem-
bles d enombrables. Dans la plupart des cas, cet ensemble sera lensemble des nombres naturels
N.
Soit A(n) une afrmation pour lentier n.
Exemple: Si A(n) d eclare que n
2
2
n
, alors A(3) dit par exemple que 9 8, ce qui
est vrai, donc A(3) est vraie. Dautre part, on peut trivialement v erier que A(5) nest pas
vraie. Dautres exemples dafrmations A(n) sont n est pair, ou n est un produit de nombres
premiers.
Si A(n) est vraie pour tout n N, alors linduction math ematique (aussi appel ee r ecurrence)
est souvent une facon el egante de le prouver.
1.2 TECHNIQUES DINDUCTION
1.2.1 Induction simple
Th eor` eme 1.1 Une afrmation A(n) est vraie pour tout n N si et seulement si les deux
conditions suivantes sont vraies:
(1) A(1)
(2) Pour tout n 1: A(n) = A(n + 1).
D enition. La technique dinduction simple consiste ` a montrer que A(n) est vraie pour tout
n N en utilisant le th eor` eme pr ec edent. Le point (1) sappelle la base dinduction et le point
(2) le pas dinduction. Dans les preuves, nous marquerons les etapes correspondantes par [Base]
et [Pas] respectivement.
15
Pour effectuer le pas dinduction, nous supposons que A(n) est vraie et montrons alors que
A(n + 1) est aussi vraie. Lhypoth` ese A(n) sappelle alors lhypoth` ese dinduction.
Preuve du th eor` eme 1.1: La partie seulement si est claire. Maintenant, si (1) et (2) sont les
deux vraies, alors pour tout n N, on a
A(1),
A(1) = A(2), donc, A(2) est vraie,
A(2) = A(3), donc, A(3) est vraie,
.
.
.
.
.
.
.
.
.
A(n 1) = A(n), donc, A(n) est vraie.
Remarque: Il nest pas n ecessaire de commencer linduction avec n = 1. En utilisant la m eme

technique, on peut prouver que A(n) est vraie pour tout n k (o` u k Z) en d emontrant A(k)
au lieu de A(1) comme base.
Pour illustrer lutilit e de linduction simple, nous montrons maintenant que la formule de
sommation de Gau est correcte.
Exemple: Soit S(n) =
n
k=1
k. Montrer que S(n) =
1
2
n(n + 1).
Soit A(n) lassertion S(n) =
1
2
n(n +1). Nous allons montrer pas r ecurrence que A(n) est
vraie pour tout n N.
[Base] S(1) = 1, donc A(1) est vraie.
[Pas] Supposons que A(n) est vraie pour un certain n, cest ` a dire supposons quon a S(n) =
1
2
n(n + 1). Nous voulons montrer que A(n + 1) est vraie:
S(n + 1) = S(n) + (n + 1)
A(n)
=
1
2
n(n + 1) + (n + 1)
=
1
2
(n + 1)(n + 2).
on a donc A(n) = A(n + 1), et donc par induction, la formule de Gau est vraie pour tout
n N.
La base dinduction est g en eralement assez facile ` a etablir; le calcul trivial dans lexemple
ci-dessus est relativement typique.
16
Remarquons aussi comment le pas dinduction a et e prouv e: nous ecrivons dabord S(n+1)
en fonction de S(n) et n, et utilisons ensuite lhypoth` ese dinduction S(n). Lendroit o` u est
utilis ee lhypoth` ese dinduction est indiqu e par la notation
A(n)
= .
Le proc ed e par r ecurrence est souvent utilis e pour montrer des assertions concernant le com-
portement de suites. Nous arrivons parfois ` a deviner une formule ferm ee sans disposer dune
preuve directe de celle-ci. Dans de tels cas, il est parfois possible de prouver la formule par
r ecurrence. Lexemple suivant illustre cette technique.
Informellement, une formule ferm ee pour une suite (u
0
, u
1
, . . .) est une formule qui nous
donne u
n
en fonction de n sans utiliser de r ecurrence sur n ni de termes ` a indices qui d ependent
de n (comme
n
i=0
ou
n
i=0
).
Par exemple u
n
= 2
n
et u
n
= n + log n sont des formules ferm ees, alors que u
n
=
n
i=1
i
2
ou u
n
= u
n1
+u
n2
ne sont pas des formules ferm ees.
Exemple: Trouver une formule ferm ee pour la suite B(n) =
n
k=0
_
n
k
_
.
Rappel: Le coefcient binomial
_
n
k
_
est d eni comme suit:
_
n
k
_
=
n!
(n k)!k!
.
Nous commencons par deviner une formule ferm ee de B(n). Pour ce faire, nous regardons ce
qui se passe quand n est petit:
1 B(0) = 1
1 1 B(1) = 2
1 2 1 B(2) = 4
1 3 3 1 B(3) = 8
1 4 6 4 1 B(4) = 16
1 5 10 10 5 1 B(5) = 32
Nous devinons donc que B(n) = 2
n
. Il faut le prouver, et pour ce faire, nous utilisons linduction.
Dans la preuve, nous aurons besoin de lidentit e suivante:
_
n + 1
k
_
=
_
n
k 1
_
+
_
n
k
_
.
Afrmation: Soit A(n) lafrmation
n
k=0
_
n
k
_
= 2
n
.
Nous aimerions montrer que A(n) est vraie pour tout n 1.
17
[Base] n = 1:
1
k=0
_
n
k
_
= 1 + 1 = 2 = 2
1
.
[Pas]
_
n+1
0
_
=
_
n
0
_
+ +
_
n+1
1
_
=
_
n
0
_
+
_
n
1
_
+ +
_
n+1
2
_
=
_
n
1
_
+
_
n
2
_
+ +
.
.
.
.
.
.
+ +
_
n+1
n
_
=
_
n
n1
_
+
_
n
n
_
+ +
_
n+1
n+1
_
=
_
n
n
_
B(n + 1) = 2 B(n)
Preuve en langage math ematique:
B(n + 1) =
n+1
k=0
_
n + 1
k
_
=
_
n + 1
0
_
. .
=1=(
n
n
)
+
n
k=1
_
n + 1
k
_
+
_
n + 1
n + 1
_
. .
=1=(
n
0
)
=
_
n
n
_
+
n
k=1
__
n
k 1
_
+
_
n
k
__
+
_
n
0
_
=
_
n
n
_
+
n1
k=0
_
n
k
_
+
n
k=1
_
n
k
_
+
_
n
0
_
=
n
k=0
_
n
k
_
. .
=B(n)
+
n
k=0
_
n
k
_
. .
=B(n)
= 2 B(n)
A(n)
= 2
n+1
.
18
1.2.2 Induction descendante
Une autre variante dinduction est linduction descendante, d ecrite dans le th eor` eme 1.2. Nous
lutiliserons plus tard pour prouver lin egalit e entre moyenne arithm etique et moyenne g eom etrique
(arithmetic-geometric-mean, AGM).
Th eor` eme 1.2 Une afrmation A(n) est vraie pour tout n N si et seulement si
1. A(n) est vraie pour une innit e de n, et
2. On a A(n) = A(n 1) pour tout n 2.
Intuitivement, ce theor` eme est vrai par le raisonnement suivant: Fixons un n pour lequel nous
aimerions etablir A(n). Choisissons ensuite un u n tel que A(u) soit vraie (ce qui est toujours
possible, car nous savons que A est vraie sur un ensemble inni, par (1)). Nous it erons ensuite
en utilisant (2): A(u) = A(u1), A(u1) = A(u2), . . . , A(n+1) = A(n). Nous
prouvons maintenant ce th eor` eme formellement:
Preuve. La partie seulement si est claire. Nous regardons donc la partie si. Supposons que
les points (1) et (2) soient vrais, et montrons que A(n) est vraie pour tout n N.

Ecrivons
U = u
1
, u
2
, . . . (avec u
1
< u
2
< ) lensemble inni sur lequel A est vraie. Nous allons
montrer les deux afrmations suivantes:
(a) Pour tout u U et tout 0 k < u, A(u k) est vraie.
(b) Pour tout n N, il existe u U et k N
0
tel que n = u k.
Ces deux afrmations r eunies impliquent que A(n) est vraie pour tout n. Nous utilisons linduction
simple pour montrer (a) et (b).
Preuve de (a). On xe u U et on proc` ede par induction sur k.
[Base] k = 0. A(u k) = A(u), ce qui est vrai.
[Pas] A(u k)
(2)
= A(u (k + 1)).
Preuve de (b)
[Base] n = 1: Posons u = u
1
, k = u
1
1:
n = 1 = u k = u
1
(u
1
1).
[Pas] Hypoth` ese dinduction: n = u
m
k pour un m 1 et un 0 k < u
m
.
Alors
n + 1 = u
m+1
. .
U
(u
m+1
u
m
1 +k)
. .
0 et <u
m+1
.
19
Exemple: Moyenne arithm etique et moyenne g eom etrique (AGM):

Th eor` eme 1.3 Pour des r eels arbitraires positifs x
1
, . . . , x
n
on a
A(n) : (x
1
x
n
)
1/n
. .
moy. g eom etrique
x
1
+ +x
n
n
. .
moy. arithm etique
Preuve. (Due ` a Cauchy, utilisant linduction descendante)
Nous d emontrons dabord que A(2
k
) est vraie pour tout k 1, ce qui montre que A(n) est
v eri ee pour une innit e de n. Ensuite, nous prouverons que si A(n + 1) est vraie, alors A(n)
lest aussi.
Fait 1: A(2
k
) est vraie pour tout k 1
Preuve: On proc` ede par induction sur k.
[Base] k = 1,
A(2)
x
1
x
2

x
1
+x
2
2
4x
1
x
2
x
2
1
+ 2x
1
x
2
+x
2
2
0 (x
1
x
2
)
2
.
La derni` ere ligne est clairement vraie, donc comme toutes les in egalites ci-dessus sont equivalentes,
on en d eduit que A(2) doit etre vraie.
[Pas] Soit n = 2
k
. Supposons que A(n) est vraie. Nous devons montrer qualors A(2
k+1
) est
vraie, i.e., que A(2n) est vraie:
20
(x
1
x
2n
)
1
2n
=
_
(x
1
x
n
)
1
n
(x
n+1
x
2n
)
1
n
A(2)
(x
1
x
n
)
1
n
+ (x
n+1
x
2n
)
1
n
2
A(n)
x
1
+ +x
n
n
+
x
n+1
+ +x
2n
n
2
=
x
1
+ +x
2n
2n
.
Donc par induction, A(2
k
) est vraie pour tout k 1.
Fait 2: A(n + 1) = A(n)
Preuve: Soit x
1
, . . . x
n
R
>0
donn e. Posons
z :=
x
1
+. . . +x
n
n
. (1.1)
Alors z R
>0
, et:
(x
1
x
n
z)
1
n+1
A(n+1)
x
1
+ +x
n
+z
n + 1
(1.1)
=
n z +z
n + 1
= z.
x
1
x
n
z z
n+1
(x
1
x
n
)
1/n
z =
x
1
+ +x
n
n
.
Le fait que A(n) est vraie pour tout n N suit des faits 1 et 2 par induction descendante
(th eor` eme 1.2).
1.2.3 Induction Forte
Rappelons que pour linduction simple, le pas dinduction consistait ` a montrer que
A(n) = A(n + 1).
Nous verrons maintenant quen fait, linduction se fait toujours si lon utilise lhypoth` ese dinduction
plus forte A(1) A(n) pour montrer A(n + 1). Cette variante dinduction sappelle
linduction forte.
21
Nous illustrerons lutilisation de linduction forte dans le paragraphe 1.3.1 en montrant la
formule dEuler pour les arbres.
Th eor` eme 1.4 Lafrmation A(n) est vraie pour tout n N si et seulement si
(1) A(1) est vraie,
(2) pour tout n N, A(1) A(n) = A(n + 1).
La preuve est tr` es similaire ` a celle du th eor` eme 1.1. Supposons que (1) et (2) sont les deux
vraies, alors pour nimporte quel n N on a
A(1) par hypoth` ese.
A(1) = A(2) Donc, A(2) est vraie, et ainsi aussi A(1) A(2).
A(1) A(2) = A(3) Donc, A(3) est vraie, et ainsi aussi A(1) A(2) A(3).
.
.
.
.
.
.
A(1) A(n 1) = A(n)
Passons maintenant aux exemples.
1.3 EXEMPLES
1.3.1 La formule dEuler pour les arbres
Nous commencons par introduire quelques notions de base de th eorie des graphes.
D enition. Un graphe est un ensemble ni V de sommets (vertices) muni dune relation E
V V , appel ee lensemble dar etes (edges).
Nous repr esentons les el ements de V par des nuds, et les ar etes par des segments orient e.
On a donc un segment orient e entre a et b si et seulement si (a, b) E. Dans ce cas nous dirons
que a est reli e (joined) ` a b.
D enition. Le graphe est non-orient e (undirected) si E est symm etrique.
Dans le cas dun graphe non-orient e, un sommet a est li e ` a un sommet b si et seulement
si b est li e ` a a. Il est donc commun de repr esenter un tel graph avec un unique segment (sans
direction) liant a et b, sans les doubles ` eches liant a ` a b et b ` a a.
Exemple:
22
Un graphe non-orient e
D enition. Une chane (path) dans un graphe est une suite de sommets distincts qui sont reli es
par des ar etes. Un cycle dans le graphe est une chane ferm ee.
Une chane Un cycle
D enition. Un graphe est dit acyclique (acyclic) sil ne continent pas de cycles. On dit que le
graphe est connexe (connected) si tout paire de sommets est reli ee par une chane.
Un graphe acyclique et connexe
D enition. Un graphe acyclique et connexe sappelle un arbre (tree).
23
Th eor` eme 1.5 (La formule dEuler pour les arbres) Si T est un arbre de n sommets, alors T
poss` ede n 1 ar etes.
Preuve. Nous procedons par induction forte sur le nombre de sommets n. Soit A(n) lafrmation
si T est un arbre sur n sommets, alors T a n 1 ar etes.
[Base] n = 1: Si larbre T na quun seul sommet alors il ne peut avoir aucune ar ete. Donc A(1)
est vraie.
[Pas] Supposons A(k) vraie pour tout 1 k n. Soit T un arbre sur n+1 sommets. Choisissons
une ar ete e dans T et enlevons-la. Comme T est connexe et acyclique, enlever e transforme T en
deux sous-arbres de n
1
et n
2
sommets respectivement, avec les n
i
< n + 1 et n
1
+n
2
= n + 1.
Lhypoth` ese dinduction permet maintenant de conclure que ces sous-arbres ont respective-
ment n
1
1 et n
2
1 ar etes. Et le nombre total dar etes de T est donc
1
er
sous-arbre
..
n
1
1 +
2
` eme
sous-arbre
..
n
2
1 +
Ar ete enlev ee e
..
1 = n.
Donc A(n + 1) est vraie. Le r esultat suit par induction forte.
1.3.2 Ensemble Independant de lHypercube
Soit G un graphe non-orient e densemble de sommets V et densemble dar etes E V V . Un
ensemble ind ependant de G est un ensemble de sommets tel quaucune paire de sommets nest
reli ee.
Un ensemble ind ependant
Le n-hypercube est le graphe densemble de sommets 0, 1
n
dans lequel deux sommets sont
reli es si et seulement si les vecteurs correspondants diff` erent en exactement une coordonn ee. (p.e.
(0, 0, 1) est reli e ` a (0, 0, 0) mais pas ` a (1, 1, 1)).
Exemple: Soit n = 2. Lensemble de sommets est V = 0, 1
2
= (0, 0), (0, 1), (1, 0), (1, 1).
Lensemble dar etes est E = [(0, 0), (0, 1)], [(0, 1), (1, 1)], [(1, 1), (1, 0)], [(1, 0), (0, 0)]. Si
24
nous dessinons ces sommets dans un espace euclidien de dimension deux, nous voyons que
le 2-hypercube est un carr e.
Similairement, le 3-hypercube est le cube de dimension trois, et le n-hypercube nous dit ` a
quoi ressemblerait un cube si nous vivions dans un espace de dimension n.
Une repr esentation du 4-hypercube
Donc, un ensemble ind ependant dans lhypercube est un sous-ensemble S 0, 1
n
pour
lequel deux vecteur distincts x, x
S diff` erent en au moins deux positions.

Nous pouvons encore utiliser linduction simple pour prouver le fait suivant concernant les
n-hypercubes:
Proposition 1 Le n-hypercube poss` ede un ensemble ind ependant de taille 2
n1
.
Preuve. Nous prouverons m eme une afrmation plus forte: Le n-hypercube poss` ede un ensem-
ble ind ependant de taille 2
n1
dont le compl ement dans 0, 1
n
est aussi ind ependant.
[Base] n = 2. V = (0, 0), (0, 1), (1, 0), (1, 1).
Lensemble (0, 0), (1, 1) est un ensemble ind ependant de taille 2 = 2
21
et son compl ement
(0, 1), (1, 0) en est aussi un.
[Pas] Soit V 0, 1
n
un ensemble ind ependant de taille 2
n1
, et soit W son compl ement (aussi
de taille 2
n1
.)
Soit U = (x, 0) [ x V (y, 1) [ y W 0, 1
n+1
. (Rappel: d enote lunion
disjointe.)
Nous montrons que U est un ensemble convenable. Remarquons dabord que clairement
[U[ = [V [ + [W[ = 2
n
. Il faut maintenant montrer que deux points distincts de U diff` erent en
au moins deux coordon ees. Pour deux points de la forme (x, 0) et (y, 1), il suft de voir que
x ,= y. Ceci est vrai, parce que x V et y W et que V et W sont disjoints. Les points
25
de la forme (x, 0) et (x
, 0) diff` erent en au moins deux coordonn ees par hypoth` ese dinduction,
comme x, x
V , o` u V est un ensemble ind ependant. Il en va de m eme pour (y, 1) et (y
, 1).
Finalement, pour completer le pas dinduction nous devons montrer que le compl ement de
U est aussi un ensemble ind ependant. Puisque U = (x, 0) [ x V (y, 1) [ y W, son
compl ement va consister en
les elements de la forme (x, 0) o` u x 0, 1
n
et x / V , cest ` a dire (x, 0) o` u x W
puisque W est le compl ement de V dans 0, 1
n
.
les elements de la forme (y, 0) o` u y 0, 1
n
et x / W, cest ` a dire (y, 0) o` u y V
puisque V est le compl ement de W dans 0, 1
n
.
Le compl ement de U dans 0, 1
n
est donc egal ` a U(x, 0) [ x W (y, 1) [ y V .
On peut donc utiliser la m eme m ethode quau dessus pour montrer que U est ind ependant.
Voici quelques exemples densembles ind ependants du n-hypercube pour n = 1, 2, 3, 4:

26
27
1.3.3 Le Lemme de Schwartz-Zippel
Soit f(x
1
, . . . , x
n
) un polyn ome en n variables sur R:
f(x
1
, . . . , x
n
) =
i
1
,i
2
,...,in
a
i
1
,...,in
x
i
1
1
x
in
n
.
Le degr e de f(x
1
, . . . , x
n
) est d eni comme suit:
deg(f) := max(i
1
+ +i
n
[ a
i
1
,...,in
,= 0).
Par exemple, le degr e de 2x
3
1
x
4
2
est 7, et le degr e de 2x
3
1
x
4
2
+x
1
x
2
x
6
3
est 8.
Th eor` eme 1.6 (Le Lemme de Schwartz-Zippel) Soit f(x
1
, . . . , x
n
) un polyn ome en n vari-
ables sur R, et soit D R un sous-ensemble ni. Soit d := deg(f). D enissons encore
Z = (a
1
, . . . , a
n
) D
n
[ f(a
1
, . . . , a
n
) = 0.
Alors,
[Z[ d[D[
n1
Ce th eor` eme est utilis e pour lanalyse de nombreux algorithmes alg ebriques al eatoires.
Preuve. Nous le prouvons par induction sur le nombre de variables n.
[Base] n = 1.
Soit f(x
1
) un polyn ome de degr e d sur R. f est un polyn ome en une variable (comme n = 1).
Nous savons par le th eor` eme fondamental de laritm etique que f(x
1
) a au plus d racines dans R.
Donc pour nimporte quel sous-ensemble D R, le nombre de racines a D peut etre au plus
d.
[Pas] Nous supposons que lassertion est vraie pour n et nous la montrons pour n + 1. Soit
f(x
1
, . . . , x
n+1
) un polyn ome en n + 1 variables. Nous avons
f(x
1
, . . . , x
n+1
) =
k
=0
x
n+1
Q
(x
1
, . . . , x
n
)
pour un k 0, et Q
k
(x
1
, . . . , x
n
) ,= 0.
Remarquons quon a deg(Q
k
(x
1
, . . . , x
n
)) d k.
1
er
cas: k = 0, i.e., f ne d epend pas de x
n+1
. f peut etre donc consid er e comme polyn ome en n
variables (auquel sapplique lhypoth` ese dinduction). Alors
[Z[ [(a
1
, . . . , a
n
) D
n
[ f(a
1
, . . . , a
n
, 0) = 0[ [D[
A(n)
d [D[
n1
[D[
= d [D[
n
.
28
2
` eme
cas: k > 0.
[Z[
M
1
..
[(a
1
, . . . , a
n
) D
n
[ Q
k
(a
1
, . . . , a
n
) = 0[ [D[ +
[(a
1
, . . . , a
n+1
) D
n+1
[ Q
k
(a
1
, . . . , a
n
) ,= 0
f(a
1
, . . . , a
n+1
) = 0[
A(1)
M
1
[D[ +k ([D[
n
M
1
)
M
1
[D[ +k [D[
n
A(n)
(d k) [D[
n1
[D[ +k [D[
n
= d [D[
n
.
29
2
Analyse dAlgorithmes
2.1 POURQUOI ANALYSER DES ALGORITHMES?
Lanalyse dalgorithmes est essentielle dans la comparaison de diff erents algorithmes pour des
probl` emes computationnels; elle nous fournit un outil pour d eterminer le meilleur algorithme
pour nos besoins.
Dans lanalyse dun algorithme nous essayons de calculer les ressources dont il aurait besoin.
De telles ressources peuvent etre, par exemple, lutilisation CPU, m emoire, temps dacc` es, etc.
Comme le nombre de facteurs qui interviennent est souvent tr` es grand, il est en g en eral tr` es
difcile de calculer exactement les ressources utilis ees. On se contente souvent de les estimer.
Dans ce chapitre, nous apprendrons des techniques pour calculer ou estimer la quantit e de
ressources utilis ees par un algorithme.
2.2 EXEMPLE: MULTIPLICATION DE POLYN
OMES
La multiplication de polyn omes est lun des probl` emes calculatoires principaux de lalg` ebre
computationelle (computational algebra) et du traitement du signal.
On rappelle quun polyn ome sur R de degr e d est une expression de la forme
p(x) = a
0
+a
1
x +a
2
x
2
+. . . +a
d
x
d
avec a
0
, . . . , a
d
R et a
d
,= 0.
Les valeurs a
0
, a
1
, . . . , a
d
sappellent les coefcients du polyn ome. Un polyn ome peut etre
d eni enti` erement par ses coefcients. Si p
1
(x) et p
2
(x) sont des polyn omes dont les degr es sont
respectivement d
1
et d
2
, alors leur produit est un polyn ome de degr e d
1
+d
2
.
30
Probl` eme: Multiplication de polyn omes
Input: (a
0
, a
1
, . . . , a
n1
), (b
0
, b
1
, . . . , b
n1
) R
n
Output: (c
0
, c
1
, . . . , c
2n2
) R
2n2
tel que
2n2
i=0
c
i
x
i
=
n1
k=0
a
k
x
k
n1
j=0
b
j
x
j
.
Les valeurs a
0
, a
1
, . . . , a
n1
et b
0
, b
1
, . . . , b
n1
sont les coefcients des polyn omes dentr ee,
et les valeurs c
0
, c
1
, . . . , c
2n2
sont les coefcients de leur produit. Remarquons quen multipliant
deux polyn omes de degr e n 1, on obtient un polyn ome de degr e 2n 2.
Si nous voulons multiplier deux polyn omes, nous pouvons simplement multiplier chaque
terme du premier polyn ome par chaque terme du deuxi` eme polyn ome et combiner les termes de
m eme exposant.
Nous voulons compter le nombre dop erations arithm etiques (cest-` a-dire dadditions et de
multiplications de nombres r eels) dont a besoin lalgorithme naf, qui effectue le calcul
c
i
=
min(i,n1)
j=max(0,i+1n)
a
j
b
ij
pour tout i = 0, 1, . . . , 2n 2.
Comptons le nombre dadditions et de multiplications ` a chaque etape.
c
0
= a
0
b
0
1 + 0
c
1
= a
0
b
1
+a
1
b
0
2 + 1
.
.
.
.
.
.
.
.
.
c
n2
= a
0
b
n2
+ +a
n2
b
0
n 1 +n 2
c
n1
= a
0
b
n1
+ +a
n1
b
0
n +n 1
c
n
= a
1
b
n1
+ +a
n1
b
1
n 1 +n 2
.
.
.
.
.
.
.
.
.
c
2n3
= a
n1
b
n2
+a
n2
b
n1
2 + 1
c
2n2
= a
n1
b
n1
1 + 0
Lalgorithme utilise
n + 2
n1
k=1
k = 2
n(n 1)
2
+n
= n
2
31
multiplications, et
n 1 + 2
n2
k=0
k = 2
(n 1)(n 2)
2
+n 1
= (n 1)
2
additions.
En additionnant ces nombres, nous obtenons le nombre total dop erations arithm etiques, qui
vaut n
2
+ (n 1)
2
.
Nous disons que lalgorithme utilise de lordre de n
2
op erations.
La notation dordre supprime les constantes multiplicatives et donne une borne sup erieure au
nombre dop erations. Nous etudierons cette notation plus en d etail dans ce chapitre.
2.3 EXEMPLE: MULTIPLICATION DE MATRICES
Probl` eme: Multiplication de matrices
Input: A = (a
ij
) R
nn
, B = (b
ij
) R
nn
Output: C = (c
ij
) R
nn
, o` u C = A B
La multiplication de matrices est un des probl` emes principaux en alg` ebre lin eaire. On peut
montrer que de nombreux probl` emes calculatoires en alg` ebre lin eaire (r esoudre des syst` emes
d equations, inversion de matrices, calcul de d eterminants, etc.) se r eduisent ` a la multiplication
de matrices.
Si A = (a
ij
) et B = (b
ij
) sont les deux des matrices n n, alors le produit matriciel
C := A B est une matrice n n, avec les composantes
c
ij
=
n
k=1
a
ik
b
kj
pour tout 1 i, j n.
Nous aimerions analyser lalgorithme naf en comptant le nombre dadditions et de multipli-
32
cations (de nombres r eels) ` a chaque pas.
c
11
= a
11
b
11
+a
12
b
21
+ +a
1n
b
n1
c
12
= a
11
b
12
+a
12
b
22
+ +a
1n
b
n2
.
.
.
.
.
.
c
ij
= a
i1
b
1j
+a
i2
b
2j
+ +a
in
b
nj
.
.
.
.
.
.
c
nn
= a
n1
b
1n
+a
n2
b
2n
+ a
nn
b
nn
Lalgorithme utilise
n
2
n
multiplications, et
n
2
(n 1)
additions.
Au total, cet algorithme effectue donc n
3
+ n
2
(n 1) op erations. Nous disons que
lalgorithme utilise de lordre de n
3
op erations arithm etiques.
La notation dordre supprime les constantes et donne la croissance approximative. Lid ee est
de ne consid erer que les termes principaux (dans ce cas n
3
) et de supprimer le reste, qui devient
insigniant quand n est grand.
n 1000 log
2
(n) 200
n 50n 10n
2
2n
3 1
32
2
n
2 1000 282.84 100 40 16 1/8
4 2000 400 200 160 128 1/2
8 3000 565.69 400 640 1024 8
16 4000 800 800 2560 8192 2048
32 5000 1131.37 1600 10240 65536 134217728
64 6000 1600 3200 40960 524288 Grand
128 7000 2262.74 6400 163840 4194304 GRAND
256 8000 3200 12800 655360 33554432 enorme
512 9000 4500.25 25600 2621440 268435456

ENORME
1024 10000 6400 51200 10485760 GRAND
2.4 LA NOTATION O
Nous aimerions mesurer des fonctions de mani` ere approximative, selon leur croissance. Ceci
nous permettra davoir une premi` ere impression du temps de parcours dun algorithme. Nous
obtiendrons ainsi une caract erisation simple de son efcacit e, permettant de comparer diff erents
types dalgorithmes.
Dans ce qui suit, toutes les fonctions sont de N vers R
>0
.
33
D enition. Pour deux fonctions f et g nous dirons que f = O(g) si
c > 0 n
0
> 0 n n
0
: f(n) cg(n).
Alors f crot au plus aussi vite que g. O se prononce grand O.
Exemple: Toute fonction est de lordre delle-m eme, on a par exemple n = O(n) et de mani` ere
g en erale f(n) = O(f(n)) pour toute fonction f(n). En effet, on peut prendre c = 1 et n
0
= 1
dans la d enition ci-dessus puisque n 1 on a f(n) 1 f(n).
Exemple: Les constantes multiplicatives ne jouent pas de r ole: 3n = O(10n), et de mani` ere
g en erale, pour toute fonction f(n) et pour tout a, b R
>0
on a:
a f(n) = O(b f(n))
On peut obtenir ce r esultat en prenant c =
a
b
et n
0
= 1 dans la d enition ci-dessus, puisque
n 1 on a a f(n)
a
b
b f(n).
Exemple: On a n
2
= O(n
3
). En effet, en prenant c = 1 et n
0
= 1 ci-dessus, on voit que n 1
on a n
2
1 n
3
.
Exemple: On a 1000n = O(n
2
). En effet, en prenant c = 1000 et n
0
= 1 ci-dessus, on voit que
n 1 on a 1000n 1000 n
2
.
Exemple: On a n + 100 = O(n
2
). On prend c = 1 et n
0
= 11 ci-dessus, on voit que n 11
on a n + 100 1 n
2
.
Exemple: On a:
n = O(1000n)
1000n = O(n)
log n = O(log n)
log n = O((log n)
2
)
n
2
= O(n
3
)
an
2
= O(bn
3
) pour tous a, b R
>0
n = O(100n
2
14n + 2)
34
1000 n
1000
= O(2
n
)
100 log(n) = O(n)
log(n) + 3 +n
2
= O(n
2
)
1 = O(n)
2003 = O(1)
1
n
= O(1)
Si p(n) est un polyn ome de degr e d, alors p(n) = O(n
d
)
Si p(n) est un polyn ome, et a > 1 alors p(n) = O(a
n
)
D enition. Pour des fonctions f et g nous ecrivons f = o(g) si
lim
n
f(n)
g(n)
= 0.
Alors, f crot plus lentement que g. On peut aussi dire que f devient insigniante par rapport
` a g lorsque n tend vers linni. o so prononce petit o.
Exemple: n = o(n
2
), en effet on a
lim
n
n
n
2
= lim
n
1
n
= 0.
Remarquons que si f = o(g), alors on a aussi f = O(g). n = o(n
2
) dans lexemple ci-dessus,
donc on a aussi n = O(n
2
).
D enition. Pour des fonctions f et g nous disons que
f = (g) si g = O(f), et
f = (g) si f = O(g) et f = (g).
Donc, si f = (g) alors f et g ont le m eme ordre de magnitude.
Exemple: On a:
n
7
= (n
6
)
35
100n
3
= (10n
3
)
1 +n + 10n
2
= o(n
3
)
1 +n + 10n
2
,= o(n
2
)
1 +n + 10n
2
= O(n
2
)
1 +n + 10n
2
= (n
2
)
n
1001
= o(1.001
n
)
Si p(n) est un polyn ome de degr e < d alors p(n) = o(n
d
).
Si p(n) est un polyn ome de degr e d alors p(n) ,= o(n
d
).
Si p(n) est un polyn ome de degr e d alors p(n) = (n
d
).
Dans ce langage nous disons que la multiplication nave de polyn omes est un algorithme
O(n
2
), ou encore que cest un algorithme avec un temps de parcours O(n
2
). La multiplication
nave de matrices est un algorithme O(n
3
), ou un algorithme avec temps de parcours O(n
3
).
Peut-on faire mieux?
Oui. Nous allons introduire puis analyser des algorithmes plus rapides pour ces deux probl` emes.
2.5 LALGORITHME DE KARATSUBA
Supposons que nous aimerions multiplier f(x) =
2n1
i=0
a
i
x
i
et g(x) =
2n1
i=0
b
i
x
i
aussi rapi-
dement que possible. Nous pouvons ecrire f(x) et g(x) comme suit.
f(x) =
_
a
0
+a
1
x + +a
n1
x
n1
_
. .
=:f
0
(x)
+x
n
_
a
n
+a
n+1
x + +a
2n1
x
n1
_
. .
=:f
1
(x)
g(x) =
_
b
0
+b
1
x + +b
n1
x
n1
_
. .
=:g
0
(x)
+x
n
_
b
n
+b
n+1
x + +b
2n1
x
n1
_
. .
=:g
1
(x)
.
Remarquons que les polyn omes f
0
(x) et f
1
(x) respectivement g
0
(x) et g
1
(x) nont que la moiti e
de taille (degr e) de f(x) respectivement g(x). Lid ee sous-jacente ` a lalgorithme de Karatsuba
est dop erer sur les polyn omes plus petits f
i
(x) et g
i
(x), o` u les calculs peuvent etre effectu es
plus rapidement.
Consid erons lalgorithme ci-dessous pour calculer f(x) g(x).
Remarquons que les op erations dans les pas 1, 2 et 5 sont elles-m emes des multiplications de
polyn omes, mais de polyn omes de taille n au lieu de 2n.
36
Algorithme 6 LAlgorithme de Karatsuba
1: h
0
(x) f
0
(x) g
0
(x).
2: h
2
(x) f
1
(x) g
1
(x).
3: u(x) f
0
(x) +f
1
(x)
4: v(x) g
0
(x) +g
1
(x).
5: A(x) u(x) v(x).
6: h
1
(x) A(x) h
0
(x) h
2
(x).
7: h(x) h
0
(x) +x
n
h
1
(x) +x
2n
h
2
(x).
8: return h(x)
Nous montrons dabord que le polyn ome h(x) calcul e est en effet le produit f(x) g(x). Pour
le voir, on calcule la valeur de h(x). Pour am eliorer la lisibilit e, nous ecrivons h au lieu de h(x),
etc.:
h = x
2n
h
2
+x
n
h
1
+h
0
= x
2n
f
1
g
1
+x
n
(uv h
0
h
2
) +f
0
g
0
= x
2n
f
1
g
1
+x
n
[(f
0
+f
1
)(g
0
+g
1
) f
0
g
0
f
1
g
1
]
. .
(f
0
g
1
+f
1
g
0
)
+f
0
g
0
= x
2n
f
1
g
1
+x
n
(f
0
g
1
+f
1
g
0
) +f
0
g
0
= (x
n
f
1
+f
0
)(x
n
g
1
+g
0
)
= f g.
Ce que nous aimerions savoir maintenant est, bien s ur, sil y a un avantage ` a utiliser lAlgorithme
6 au lieu de lalgorithme naf introduit dans la section 2.2. Analysons donc son temps de par-
cours.
Pour multiplier deux polyn omes de degr e < 2n, nous avons besoin de 3 multiplications de
polyn omes de degr e < n, 2 additions de polyn omes de degr e < n et 2 additions de polyn omes
de degr e < 2n 1 et de 2 additions de co ut 2(n 1) ( etape 7).
h (x)
h (x)
h (x)
0
1
2
x
n
x
2n
0 n 2n2
2n 3n2
4n2
n1
n1
Commencons par supposer que nous utilisons lalgorithme naf de multiplication de polyn omes
dans les etapes 1, 2 et 5 de lalgorithme de Karatsuba. Puisque, en utilisant lalgorithme naf,
37
nous avons besoin de n
2
+ (n 1)
2
op erations arithm etiques pour multiplier des polyn omes de
degr e < n, le nombre total dop erations pour multiplier deux polyn omes de degr e < 2n utilisant
la m ethode de Karatsuba est:
3 (n
2
+ (n 1)
2
) + 2 n + 2 (2n 1) + 2 (n 1) = 6n
2
+ 2n 1,
tandis que lalgorithme naf n ecessite
8n
2
4n + 1
op erations, ce qui est plus grand par un facteur dapproximativement 4/3 si n est grand. Ainsi,
de cette mani` ere nous obtenons un algorithme qui est plus rapide que lalgorithme naf, mais ceci
seulement par un facteur constant: il sagit toujours dun algorithme O(n
2
).
Heureusement, ce nest pas la n de lhistoire. Nous pouvons utiliser lalgorithme de Karat-
suba lui-m eme dans les pas 1, 2 et 5 pour obtenir un algorithme qui est encore plus performant.
De tels algorithmes, qui font appel ` a eux-m emes pour accomplir leur t ache, sappellent des algo-
rithmes r ecursifs. Nous etudierons les algorithmes r ecursifs encore plus en d etail.
Analysons maintenant le comportement du vrai algorithme de Karatsuba, i.e., de la variante
r ecursive. Nous d enissons les fonctions M(), A() et T() comme suit:
M(n): le nombre de multiplications pour multiplier deux polyn omes de degr e < n.
A(n): le nombre dadditions / soustractions pour multiplier deux polyn omes de degr e < n.
T(n): le nombre total dop erations arithm etiques pour multiplier deux polyn omes de degr e
< n, dans ce cas egal ` a A(n) +M(n).
Nous avons clairement M(1) = 1, A(1) = 0, et nous pouvons calculer les valeurs de
M(), A() et T() pour les puissances de deux en utilisant les r ecurrences suivantes:
M(2n) = 3M(n)
A(2n) = 3A(n) + 2n + 2(2n 1) + 2(n 1)
= 3A(n) + 8n 4,
T(2n) = 3T(n) + 8n 4
Par exemple, la formule pour A(2n) ci-dessus se trouve comme suit: Le terme 3A(n) vient
des multiplications r ecursives dans les etapes 1, 2 et 5 de lalgorithme 6. Le terme 2n vient
des multiplications de polyn omes de degr e < n dans les etapes 3 et 4. Le terme 2(2n 1)
vient des deux soustractions de polyn omes de degr e < 2n 1 dans l etape 6. Finalement, le
terme 2(n 1) vient des additions dans l etape 7. (Dans ce dernier cas, il suft de compter les
additions des parties qui se recouvrent; c.f. lillustration ` a la page pr ec edente.)
Comment les fonctions M(n), A(n) et A(n) +M(n) croissent-elles en fonction de n? Nous
apprendrons des techniques pour r epondre ` a ce type de question plus tard dans ce chapitre.
Nous pouvons, par contre, d ej` a faire une comparaison num erique pour le cas o` u n est une
puissance de deux. Nous obtenons
38
Karatsuba Naive
n Mult. Add. Total Mult. Add. Total
2 3 4 7 4 1 5
4 9 24 33 16 9 25
8 27 100 127 64 49 113
16 81 360 441 256 225 481
32 243 1204 1447 1024 961 1985
64 729 3864 4593 4096 3969 8065
128 2187 12100 14287 16384 16129 32513
Tandis que pour n petit, la multiplication nave semble etre meilleure, nous voyons que pour
n 16, lalgorithme de Karatsuba est plus rapide. (En r ealit e, la multiplication est souvent plus
co uteuse que laddition, et lalgorithme de Karatsuba pourrait donc etre meilleure m eme pour
des n plus petits).
Nous montrerons plus tard que lalgorithme de Karatsuba est O(n
log
2
(3)
), ce qui est beaucoup
mieux que lalgorithme naf O(n
2
), comme log
2
(3) 1.585.
Lutilisation de structures de donn ees ad equates rend aussi possible de r ealiser ce gain sur
des machines r eelles et dans les applications pratiques. Par exemple, quelques impl ementations
de puces cryptographiques utilisent cet algorithme. Et m eme si de nos jours, des algorithmes
meilleurs sont connus pour la multiplication de polyn omes, lalgorithme de Karatsuba sutilise
souvent dans les logiciels informatiques (par exemple, PARI/GP), parce que cest un algorithme
qui donne une bonne performance en restant relativement facile ` a impl ementer.
2.6 LALGORITHME DE STRASSEN
Dans la section pr ec edente, nous avons appris que la multiplication de polyn omes peut etre ef-
fectu ee plus rapidement en d ecomposant les polyn omes en des parties plus petites et en effectu-
ant ensuite les calculs sur ces polyn omes plus petits. Cette strat egie de division de probl` emes en
sous-probl` emes plus petits peut aussi etre appliqu ee dans dautres contextes; ce type dalgorithme
sappelle un algorithme diviser-pour-r egner (divide-and-conquer).
Dans cette section, nous pr esentons un algorithme diviser-pour-r egner pour la multiplication
de matrices.
Supposons que nous aimerions calculer le produit de deux matrices A et B,
_
C
11
C
12
C
21
C
22
_
=
_
A
11
A
12
A
21
A
22
_
_
B
11
B
12
B
21
B
22
_
39
o` u C
ij
, A
ij
, B
ij
sont des matrices n n.
La d ecomposition en blocs ci-dessus sugg` ere que si nous connaissions un algorithme perfor-
mant pour la multiplication de matrices 2 2, ceci nous permettrait de construire un algorithme
g en eral (i.e., pour n arbitraire) performant de multiplication de matrices en utilisant la technique
diviser-pour-r egner.
Strassen a invent e un tel algorithme pour la multiplication de matrices 2 2 en 1969. Nous
pr esentons ici la variante am elior e de Winograd de lalgorithme de Strassen qui n ecessite encore
moins dadditions. Les pas sont:
(1) Calculer
S
1
= A
21
+A
22
T
1
= B
12
B
11
S
2
= S
1
A
11
T
2
= B
22
T
1
S
3
= A
11
A
21
T
3
= B
22
B
12
S
4
= A
12
S
2
T
4
= B
21
T
2
(2) Calculer
P
1
= A
11
B
11
P
5
= S
3
T
3
P
2
= A
12
B
21
P
6
= S
4
B
22
P
3
= S
1
T
1
P
7
= A
22
T
4
P
4
= S
2
T
2
et
U
1
= P
1
+P
2
U
5
= U
3
+P
3
U
2
= P
1
+P
4
U
6
= U
2
+P
3
U
3
= U
2
+P
5
U
7
= U
6
+P
6
U
4
= U
3
+P
7
.
(3) Ensuite,
C
11
= U
1
, C
12
= U
7
,
C
21
= U
4
, C
22
= U
5
.
Pour multiplier deux matrices 2n 2n, lalgorithme naf utilise 8 multiplications et 4 ad-
ditions de matrices n n. Lalgorithme de Strassen r eduit ceci ` a 7 multiplications et 15 addi-
tions/soustractions de matrices n n. (Remarquons que le nombre dadditions de matrices nest
pas vraiment tr` es important, puisquelle se fait el ement par el ement, donc en O(n
2
) tandis que la
multiplication nave est O(n
3
)).
Pour analyser le temps de parcours de lalgorithme de Strassen, nous introduisons de nouveau
les fonctions M(), A(), T():
M(n): Nombre de multiplications (de r eels) pour multiplier des matrices n n.
A(n): Nombre dadditions (de r eels) pour multiplier des matrices n n.
T(n): Le nombre total dop erations arithm etiques pour la multiplication de matrices nn.
40
Pour les puissances de deux, ces fonctions sont donn ees par les formules r ecursives
M(2n) = 7M(n)
A(2n) = 7A(n) + 15n
2
T(2n) = 7T(n) + 15n
2
,
et les conditions initiales M(1) = 1, A(1) = 0, T(1) = 1.
Dans la section 2.7 nous apprendrons comment d eduire de ces formules que lalgorithme
de Strassen est O(n
log
2
(7)
). Lalgorithme de Strassen est donc beaucoup plus performant que
lalgorithme naf O(n
3
), puisque log
2
(7) 2.81. Le bon choix de structures de donn ees aide ` a
r ealiser cet avantage en pratique.
2.7 RELATIONS DE R
ECURRENCE
Th eor` eme 2.1 Soit T : N R une fonction telle quil existe b, c, d R
>0
, et a N avec
(a) T(n) T(n + 1) pour tout n 1 (i.e. T() crot monotonement), et
(b) T(an) cT(n) +dn
b
.
On a alors
(1) Si a
b
< c, alors T(n) = O
_
n
log
a
(c)
_
.
(2) Si a
b
= c, alors T(n) = O
_
n
log
a
(c)
log
a
(n)
_
.
(3) Si a
b
> c, alors T(n) = O
_
n
b
_
.
Avant de prouver ce th eor` eme, nous lutilisons pour obtenir les temps de parcours estim es des
algorithmes de Karatsuba et Strassen.
Corollaire 1 Lalgorithme de Karatsuba utilise O(n
log
2
(3)
) op erations.
Preuve. La fonction T(n) d enote le nombre dop erations pour multiplier des polyn omes de degr e
< n. Nous pouvons clairement supposer T(n) T(n + 1), car si n nest pas une puissance de
deux, nous pouvons r esoudre le probl` eme en remplissant les coefcients de f respectivement g
plus grand que n avec des z eros, jusqu` a la prochaine puissance de deux. (Cest du zero-padding).
Donc lhypoth` ese (a) du th eor` eme 2.1 est bien v eri ee.
Nous avons T(2n) = 3T(n) +8n4 3T(n) +8n. Donc, lhypoth` ese (b) est v eri ee avec
a = 2, b = 1, c = 3, et d = 8. En appliquant le th eor` eme, nous obtenons le corollaire.
41
Corollaire 2 Lalgorithme de Strassen utilise O(n
log
2
(7)
) op erations.
Preuve. Nous avons T(n) T(n + 1) pour la m eme raison quau corollaire pr ec edent. Nous
savons que T(2n) 7T(n) + 15n
2
. Donc nous pouvons appliquer le th eor` eme avec a = 2,
b = 2, c = 7, et d = 15.
Pour pouvoir prouver le th eor` eme 2.1, nous avons besoin de la proposition suivante:
Proposition 2 Soit u R. Alors pour tout k 1:
k1
=0
u
=
_
k si u = 1
u
k
1
u1
si u ,= 1.
De plus, si [u[ < 1, alors
k1
=0
u
<
=0
u
=
1
1 u
.
Nous laissons la preuve comme exercice.
Preuve du th eor` eme 2.1. La preuve consiste en 3 etapes:
Etape 1: Nous montrons que pour tout k 1,

T(a
k
) c
k1
_
cT(1) +d
k1
=0
_
a
b
c
_
_
.
Nous montrons ceci par induction sur k.
[Base] : k = 1. On a T(a) cT(1) +d, en utilisant lhypoth` ese (b) du th eor` eme avec n = 1.
[Pas] : Lapplication de la premi` ere etape suivi de lhypoth` ese dinduction donne
T(a
k+1
) cT(a
k
) +da
kb
Hyp.
c
k
_
cT(1) +d
k1
=0
_
a
b
c
_
_
+da
kb
= c
k
_
cT(1) +d
k1
=0
_
a
b
c
_
+d
_
a
b
c
_
k
_
= c
k
_
cT(1) +d
k
=0
_
a
b
c
_
_
.
42
Etape 2: nous montrons quil existe , , R

>0
tel que pour tout k 1:
T(a
k
)
_
_
c
k
si a
b
< c
kc
k
si a
b
= c
a
kb
si a
b
> c
1. Si a
b
< c, la Proposition 2 implique que
k1
=0
_
a
b
c
_
<
1
1
a
b
c
pour tout k. En utilisant cette in egalit e et l etape 1, nous obtenons
T(a
k
) c
k1
_
cT(1) +d
1
1
a
b
c
. .
=:
_
= c
k
T(1) +c
k1
=
_
T(1) +

c
_
. .
=:
c
k
.
2. Si a
b
= c, alors
k1
=0
_
a
b
c
_
= k, et donc avec l etape 1 on obtient lestimation suivante:

T(a
k
) c
k1
(cT(1) +dk)
= c
k
_
T(1) +
kd
c
_
=
_
T(1)
k
+
d
c
_
. .
=:
kc
k
.
3. Si a
b
> c,
k1
=0
_
a
b
c
_
=
_
a
b
c
_
k
1
a
b
c
1
_
a
b
c
_
k
1
a
b
c
1
. .
=:
.
43
Donc nous avons
T(a
k
) c
k
T(1) +c
k1
d
_
a
b
c
_
k
= c
k
T(1) +
d
c
a
kb
= a
kb
__
c
a
b
_
k
. .
<1
T(1) +
d
c
_
_
T(1) +
d
c
_
. .
=:
a
kb
.
Etape 3: Preuve du th eor` eme.
Etant donn e n, nous trouvons k tel que a

k1
n < a
k
. Nous aurons alors les trois in egalit es
suivantes:
a
k
an (2.1)
k 2 log
a
(n) (2.2)
T(n) T(n + 1) T(a
k
) (Induction!) (2.3)
Si a
b
< c, alors
T(n) T(a
k
)
c
k
= (a
k
)
log
a
(c)
(2.1)
c n
log
a
(c)
,
donc, T(n) = O(n
log
a
(c)
).
Si a
b
= c, alors
T(n) T(a
k
)
kc
k
= k(a
k
)
log
a
(c)
(2.1)
ck n
log
a
(c)
(2.2)
2c n
log
a
(c)
log
a
(n),
do` u, T(n) = O(n
log
a
(c)
log
a
(n)).
44
Si a
b
> c, alors
T(n) T(a
k
)
a
kb
(2.1)
a
b
n
b
,
donc T(n) = O(n
b
).
Ceci termine la preuve du th eor` eme.
2.8 REMARQUES FINALES
En analysant un algorithme il est important:
Didentier les op erations qui prennent du temps,
Danalyser combien de telles op erations sont n ecessaires,
Didentier une relation entre cette analyse et les vraies machines.
Nous avons d evelopp e la notation O() pour comparer les algorithmes asymptotiquement, i.e.,
quand le nombre de variables dinput est tr` es grand. La notation O() ne prend pas en compte les
constantes. Cependant, en pratique elles sont tr` es importantes.
La notation O() pr edit une certaine performance, mais le comportement dun algorithme sur
une vraie machine d epend de nombreux facteurs dont le choix des structures de donn ees.
Cest ce qui nous concernera dans le prochain chapitre.
45
3
Structures de donnees
elementaires
Un programme C ou C++ contient dhabitude une partie algorithmique et une partie d eclaratoire.
La partie algorithmique (contenue typiquement dans les chiers .c) contient proprement des
algorithmes, i.e., une description de comment les donn ees doivent etre manipul ees. La partie
d eclaratoire (en C dans les chiers .h) contient les prototypes, les typedef et les d eclarations
de structures et classes. Autrement dit, la partie d eclaratoire d ecrit comment les morceaux
dinformations li es sont organis es, donc les structures de donn ees.
Algorithme + Structures de donn ees = Programme
Le bon choix de structures de donn ees est une partie crucial dune impl ementation perfor-
mante dun algorithme.
Dans ce chapitre nous etudierons quelques structures de donn ees el ementaires et quelques
types abstraits (abstract data types).
3.1 ENSEMBLES DYNAMIQUES
Tr` es souvent, les algorithmes manipulent des ensembles de donn ees. Ces ensembles ne sont pas
statiques, mais peuvent grandir ou diminuer au cours du temps. Ce type densemble est appel e
dynamique.
Impl ementation typique: Les ensembles dynamiques sont repr esent es comme des objets
(structures) dont les membres individuels peuvent etre inspect es et manipul es. Lacc` es aux mem-
bres est donn e via un pointeur sur lobjet.
Pour la plupart des ensembles dynamiques, lun des membres de lobjet est la cl e, i.e., un
identicateur unique de lobjet. Les autres membres de lobjet contiennent dautres donn ees
dint er et.
Nous supposerons r eguli` erement que la cl e appartient ` a un ensemble totalement ordonn e
(comme par exemple N). Un ensemble S est totalement ordonn e par rapport ` a une relation <
0
si
pour tous a, b S, exactement une des trois conditions suivantes est vraie: a <
0
b, b <
0
a ou
a = b.
46
Les op erations sur les ensembles dynamiques appartiennent ` a deux types: les demandes et
les op erations de modication.
Les demandes donnent de linformation sur les el ements de lensemble.
Les op erations de modication changent lensemble.
Ecrivons S un ensemble dynamique, x un objet ( el ement) que S peut stocker, et k la cl e

dun el ement. Les op erations suivantes sur les ensembles dynamiques sont souvent utilis ees en
pratique:
Op erations de modication:
Insert(S, x): Op eration de modication qui ajoute l el ement x ` a S
Delete(S, x): Op eration de modication qui efface x de S si x appartient ` a S.
Demandes:
Search(S, k): Retourne un pointeur sur un el ement x S tel que key[x] = k si un tel
el ement existe, et NULL sinon.
Minimum(S): Retourne l el ement avec la cl e la plus petite.
Maximum(S): Retourne l el ement avec la cl e la plus grande.
Successor(S, x): Retourne, pour un el ement x donn e, le prochain plus grand el ement
dans S, cest-` a-dire l el ement avec la plus petite cl e qui soit plus grande que celle de x.
Retourne NULL si x est l el ement maximal.
Predecessor(S, x): Cest lanalogue de la fonction Successor. Retourne pour x
donn e le prochain plus petit el ement ou NULL si x est l el ement minimal.
Le temps n ecessaire pour accomplir ces t aches est souvent donn e en fonction de la taille
de lensemble. Par exemple, nous serons souvent int eress es par des structures de donn ees qui
effectuent les op erations ci-dessus en temps O(log(n)), o` u n est la taille de lensemble.
3.2 STRUCTURES DES DONN
EES DYNAMIQUES

EL
EMEN-
TAIRES
Dans ce chapitre nous etudierons les stacks, les les dattente et les listes li ees. Ce sont des
types abstraits, cest-` a-dire que leur fonctionalit e est d enie mais ils peuvent etre impl ement es
(r ealis es) de diff erentes facons. Nous verrons pour chacun de ces trois types une impl ementation
(r ealisation) qui utilise un tableau (array).
47
3.2.1 Stack (ou pile)
Un stack est une structure de donn ees qui permet dempiler des objets: Lintuition est qu` a
chaque fois quon ajoute quelque chose sur une pile, on le met par dessus les objets d ej` a pr esents.
On ne peut enlever que lobjet le plus haut. Ce principe sappelle dernier-entr e, premier-sorti
(LIFO, Last-in, First-out).
Lop eration dajout dun objet au stack sappelle push et lop eration denl` evement est nomm ee
pop. Une troisi` eme op eration indiquant si le stack est vide est parfois ajout ee.
On peut r ealiser (impl ementer) un stack avec un tableau (array) et un indice qui indique la
premi` ere position vide (ou alternativement, la derni` ere position occup ee).
Illustration:
0 1 2 3 4 5 6
15 6 2 9
top[S] = 3
S
Voici un stack S contenant 4 el ements. Les cases sont des positions dans larray de limpl ementation.
Le stack poss` ede un attribut top[S] qui est lindice indiquant la plus haute position occup ee.
0 1 2 3 4 5 6
15 6 2 9 17 3
top[S] = 5
S
Le m eme stack S apr` es Push(S, 17) et Push(S, 3).
0 1 2 3 4 5 6
15 6 2 9 17 3
top[S] = 4
S
Lop eration Pop(S) retourne 3 et efface ensuite cet el ement de S (i.e. top[S] est diminu e de un).
Si on essaye deffectuer un Pop(S) sur un stack S vide, lop eration Pop retourne un code
indiquant ce fait et on dit alors quon a stack underow.
48
Les algorithmes 7, 8, 9 donnent une r ealisation standard dun stack bas e sur un tableau (ar-
ray).
Algorithme 7 StackIsEmpty(S)
1: if top[S] = 0 then
2: return true
3: else
4: return false
5: end if
Algorithme 8 Push(S, x)
1: top[S] top[S]+1
2: S[top[S]] x
Algorithme 9 Pop(S)
1: if StackIsEmpty(S) then
2: return underow
3: else
4: top[S] top[S]-1
5: return S[top[S] + 1]
6: end if
Exemple: Les stacks sont tr` es souvent utilis es dans la programmation. Quelques exemples:
Stack d evaluation dexpressions: Pour pouvoir evaluer des expressions comme
((a +b) (c +d)) + (e f) (3.1)
on se sert dun stack qui stocke les r esultats interm ediaires. Les programmes qui evaluent
ce type dexpression se servent typiquement dun stack. Lexpression (3.1) se traduit alors
en la suite dinstructions suivante:
Push(S, a)
Push(S, b)
Push(S, Pop(S) +Pop(S))
Push(S, c)
Push(S, d)
Push(S, Pop(S) +Pop(S))
Push(S, Pop(S) Pop(S))
Push(S, e)
Push(S, f)
49
Push(S, Pop(S) Pop(S))
return Pop(S) +Pop(S)
Pour des valeurs de a, b, c, d, e et f donn ees, la suite ci-dessus retourne alors l evaluation
de lexpression.
(Certaines calculatrices de la marque HP laissent ` a lutilisateur ce pas de traduction, et
prennent comme input directement les op erations Push (la touche enter), et les op erateurs.
Cette m ethode sappelle reversed polish notation.)
Stack dadresse retour: Pour stocker ladresse retour dune sous-routine. Un tel stack est
utilis e par exemple dans les applications r ecursives. Les sous-routines sont ainsi ex ecut ees
dans lordre de leur ordre dappel.
Stack de variable locale: Pour g erer les variables locales dans des programmes r ecursifs.
Stack de param` etres: Pour stocker les param` etres sur lesquels agit une sous-routine. (les
valeurs dinput dun programme par exemple).
Remarquons que quasi tous les programmes informatiques disposent au moins dun stack:
Cest le stack qui contient ` a la fois les variables locales, les adresses de retour et sur lequel
les arguments pour les sous-routines sont pass es. Ce stack sert aussi a stocker des r esultats
interm ediaires.
On peut par exemple utiliser un stack pour v erier les parenth` eses dune expression:
Probl` eme: V erication de parenth` eses
Input: Une expression contenant du texte et (, ), [, ], ,
Output: correct ou incorrect, selon si toutes les parenth` eses ouvrantes
sont ensuite ferm ees.
Nous utilisons un stack S, initialement vide.
La condition l el ement le plus haut de S ne correspond pas ` a c est d enie par:
( correspond ` a )
[ correspond ` a ]
correspond ` a
Exemple: ((1 + 9) 93 (98)/23 (43 + 2) est une expression incorrecte, la toute premi` ere
parenth` ese nest pas ferm ee. Lexpression [(1 + 9) 93 (98)/23 (43 + 2)] est correcte.
50
Algorithme 10 VERIFICATIONPARENTHESES
1: while Input pas ni do
2: c prochain caract` ere
3: if c=( ou c=[ ou c= then
4: Push(S, c);
5: end if
6: if c=) ou c=] ou c= then
7: if StackIsEmpty(S) ou l el ement le plus haut de S ne correspond pas ` a c then
8: return Incorrect
9: else
10: Pop(S);
11: end if
12: end if
13: end while
14: if StackIsEmpty(S) then
15: return Correct
16: else
17: return Incorrect
18: end if
3.2.2 Files dattente (Queues)
Les les dattente sont des ensembles dynamiques qui permettent de nouveau denlever et dajouter
des el ements. Cette fois, on ne peut ajouter qu` a la n et enlever quau d ebut, i.e., si on enl` eve,
on enl` eve toujours le plus ancien el ement encore dans la queue. Cest le principe premier-entr e,
premier-sorti (en anglais: rst-in-rst-out, FIFO). Nous appelons lop eration denl` evement dun
el ement dequeue, et celle dajout enqueue.
Il est de nouveau possible de se servir dun tableau (array) pour r ealiser une le dattente,
si nous savons que la queue ne d epassera pas une certaine taille. Nous avons besoin de deux
attributs, ` a savoir dun attribut qui indique la prochaine position libre ` a la n de la queue, et un
attribut qui indique la position du plus vieil el ement de la queue (i.e. la position du prochain
el ement ` a enlever). Nous appellerons ces attributs respectivement tail et head.
Lid ee est maintenant de remplir ` a chaque fois la position tail si Enqueue est appel e, et
densuite incr ementer tail. Si tail d epasse la n du tableau, on recommence ` a la premi` ere
position. La fonction Dequeue proc` ede de mani` ere similaire: Ayant lu la valeur de la position
head ` a retourner, ce compteur est incr ement e et remis ` a un sil d epasse la n du tableau.
Exemple:
51
0 1 2 3 4 5 6 7 8 9 10
15 6 9 8 4
head[Q] tail[Q]
Q
Le dessin ci-dessus repr esente une le dattente Q avec 5 el ements aux positions Q[6..10]. Si
nous faisons les op erations Enqueue(Q, 17), Enqueue(Q, 3) et Enqueue(Q, 5), nous aurons
alors la situation suivante:
0 1 2 3 4 5 6 7 8 9 10
15 6 9 8 4 17 3 5
head[Q] tail[Q]
Q
Remarquons quapr` es avoir ajout e 17, la valeur de tail est remise ` a 1. Si nous faisons ensuite
lop eration Dequeue(Q), la valeur 15 est retourn ee, et la queue se trouve dans l etat suivant:
0 1 2 3 4 5 6 7 8 9 10
15 6 9 8 4 17 3 5
head[Q] tail[Q]
Q
Les algorithmes 12 et 13 donnent des r ealisations concr` etes des op erations Enqueue respec-
tivement Dequeue pour des queues bas ees sur un tableau. Remarquons que si head[Q] =
tail[Q], la queue pourrait etre soit pleine ou soit vide. Pour diff erencier ces deux cas nous posons
head[Q]= NULL lorsque la queue est vide. Ainsi linitialisation est la suivante:
Algorithme 11 Initialize(Q)
1: head[Q] NULL
2: tail[Q] 1
Les les dattente sont utilis ees quand des t aches doivent etre trait ees dans leur ordre darriv ee.
Exemple: Les queues sont utilis ees de mani` ere visible ` a lutilisateur dans les situations suiv-
antes:
52
Algorithme 12 Enqueue(Q, x)
1: if head[Q]=tail[Q] then
2: error overow
3: end if
4: Q[tail[Q]] x
5: if head [Q] = NULL then
6: head [Q] tail[Q]
7: end if
8: if tail[Q] = length[Q] then
9: tail[Q]1
10: else
11: tail[Q] tail[Q]+1
12: end if
Algorithme 13 Dequeue(Q)
1: if head [Q] = NULL then
2: error underow
3: end if
4: x Q[head[Q]]
5: if head[Q] = length[Q] then
6: head[Q] 1
7: else
8: head[Q] head[Q]+1
9: end if
10: if head[Q] = tail[Q] then
11: head[Q] NULL
12: end if
13: return x
53
Routers: Les t aches sont des paquets, il faut d eterminer ` a quel router le paquet doit etre
envoy e. On utilise une le dattente pour traiter les paquets dans lordre.
Appels t el ephoniques: Quand on appelle un num ero 0800 en Suisse, lappel est mis dans
une queue en attendant d etre trait e. Dans la situation id eale, les appels sont trait es dans
leur ordre darriv ee.
Imprimantes: Quand on envoie une t ache ` a une imprimante, elle est ins er ee dans une le
dattente.
Les tampons (buffers) sont des types particuliers de les dattente, contenant un ux de
donn ees ` a traiter. Les interfaces de transmission de donn ees utilisent des tampons. Par exemple,
les donn ees ` a ecrire sur un disque dur sont dabord stock ees sur un tampon.
Il existe des les dattente qui prennent en compte les priorit es, appel ees des les dattente
avec priorit e (Priority Queues). Cette variante ne nous concernera pas dans ce cours.
3.2.3 Listes liees (Linked lists)
Une liste li ee est une facon simple et exible de repr esenter un ensemble dynamique. Elle permet
dimpl ementer toutes les op erations mentionn ees dans la section 3.1. Il sagit dune structure de
donn ees dans laquelle les objets sont ordonn es de facon lin eaire. Lordre est donn e par des
pointeurs associ es ` a chaque objet.
Il y a plusieurs types de listes li ees. Nous regarderons ici les listes doublement li ees. Les
el ements de ce type de liste poss` edent chacun deux pointeurs, prev et next. Le pointeur prev
pointe sur le pr ed ecesseur (dans la liste) de l el ement, et nextsur le successeur. Si prev[x] =
NULL alors x est le premier el ement (head) de la liste, et si next[x] = NULL, alors x est le
dernier el ement (tail).
Nous avons encore besoin dun attribut head[L], qui est un pointeur indiquant le premier
el ement de la liste. Pour une liste L vide, on a head[L] = NULL.
Exemple:
head[L] 9 4
prev
key
next
1
Cest une liste doublement li ee L qui repr esente (9, 4, 1).
head[L] 5 9 4 1
54
La liste L apr` es Insert(L, x), avec key[x] = 5.
head[L] 5 9 1
La liste L apr` es Delete(L, x), avec key[x] = 4.
Les algorithmes 14, 15 et 16 montrent comment chercher, ins erer et effacer des objets dans
une liste doublement li ee.
Algorithme 14 Search(L, k)
1: x head[L]
2: while x ,= NULL et key[x] ,= k do
3: x next[x]
4: end while
5: return x
Algorithme 15 Insert(L, x)
1: next[x] head[L]
2: prev[x] NULL
3: if head[L] ,= NULL then
4: prev[head[L]] x
5: end if
6: head[L] x
Algorithme 16 Delete(L, x)
1: if prev[x] ,= NULL then
2: next[prev[x]] next[x]
3: else
4: head[L] next[x]
5: end if
6: if next[x] ,= NULL then
7: prev[next[x]] prev[x]
8: end if
3.3 GRAPHES ET ARBRES
Les graphes sont des structures de donn ees g en erales qui peuvent etre utilis ees pour repr esenter
des d ependances et des relations entre des objets. Ils sont tr` es souvent utilis es en informa-
tique, par exemple pour d ecrire la structure du hardware, des r eseaux informatiques, des ux de
55
donn ees, des syst` emes parall` eles et des structures hi erarchiques (arbres). On rappelle la d enition
dun graphe et des d enitions sy rapportant.
D enition. Un graphe (V, E) est un ensemble ni de sommets V et une relation E V V .
D enition.
Pour a, b V nous disons quil y a une ar ete de a ` a b si (a, b) E.
Un chemin de longueur n est une suite de n ar etes
(c
0
, c
1
), (c
1
, c
2
), . . . , (c
n2
, c
n1
), (c
n1
, c
n
).
Un chemin pour lequel c
0
= c
n
est appel e un cycle.
Un graphe est dit connexe sil existe un chemin entre a et b pour tout (a, b) V
2
tel que a
est diff erent de b.
Le in-degr e dun sommet a dans un graphe est le nombre dar etes qui vont vers a, i.e.,
[b V [ (b, a) E[.
Le out-degr e dun sommet a est le nombre dar etes qui sortent de a, i.e., [b V [ (a, b)
E[.
Un voisin dun sommet x dun graphe est un autre sommet y tel que x et y sont li es (i.e.,
ont une ar ete en commun).
Un graphe est dit non-orient e si E est sym etrique.
Dans un graphe non-orient e, le degr e dun sommet a est le nombre de sommets adjacents ` a
a, i.e.,
deg(a) = [b E [ (a, b) E[.
Exemple: G
1
et G
2
sont des graphes non-orient es.
G
1
:
v
w
connexe;
a un cycle de longueur 3.
56
G
2
:
non-connexe;
sans cycles
On voit que G
1
a 7 sommets et 7 ar etes, et que G
2
a 6 sommets et 4 ar etes. Dans G
1
le
sommet v est de degr e 1, et le sommet w est de degr e 3.
3.3.1 Representer des graphes
Comment peut-on repr esenter des graphes de mani` ere efcace dans un ordinateur? Nous allons
etudier deux des plus importantes m ethodes.
Repr esentation par une matrice dadjacence
Consid erons un graphe G = (V, E), o` u V = v
1
, . . . , v
n
. La matrice dadjacence de G est une
matrice A = (a
ij
)
1i,jn
, telle que pour tout i et j nous avons a
ij
0, 1, d enis comme suit:
a
ij
:=
_
1, si (v
i
, v
j
) E
0, sinon.
La quantit e de m emoire n ecessaire est n
2
bits pour des graphes orient es. Pour les graphes non-
orient es, nous avons a
ij
= a
ji
, et donc la quantit e de m emoire n ecessaire est 1 + 2 + + n =
n(n+1)
2
bits.
Exemple: Consid erons le graphe orient e G, et sa matrice dadjacence A:
G =
v
1
v
2
v
3
v
4
A =
_
_
_
_
0 1 0 1
0 0 0 1
0 1 1 0
0 0 0 0
_
_
_
_
On voit que le nombre de 1 dans la matrice dadjacence est egal au nombre dar etes dans le
graphe.
Remarquons les faits suivants:
le in-degr e de v
2
est 2, et il y a 2 fois la valeur 1 dans la 2
` eme
colonne de A.
le out-degr e de v
2
est 1, et il y a 1 fois la valeur 1 dans la 2
` eme
ligne de A.
le in-degr e de v
3
est 1.
57
le out-degr e de v
4
est 0.
En effet, par d enition de A le nombre de 1 dans la colonne de A qui correspond au sommet
V est egal au in-degr e de V , et le nombre de 1 dans la ligne qui correspond ` a V est egal au
out-degr e de V .
Avantages:
Repr esentation simple.
On a un acc` es efcace, i.e., tester si deux sommets sont li es peut etre rapidement effectu e.
D esavantages:
N ecessite beaucoup de m emoire (O(n
2
)), ind ependamment du nombre dar etes dans le
graphe.
Statique. Ne permet pas facilement dagrandir le graphe.
Repr esentation par des listes dadjacence
Pour chaque sommet v V nous stockons une liste L
v
de sommets voisins de v. Par exemple,
en C++ ceci peut etre fait comme suit:
typedef int vertices;
struct List
vertices value;
List
*
next;
;
List graph[n];
Ainsi, le graphe est repr esent e comme un tableau (array) de listes dadjacence. Il y a une liste
par sommet v du graphe dans laquelle sont stock es tous ses voisins.
Exemple: Le graphe G de lexemple pr ec edent peut etre repr esent e par les 4 listes suivantes:
58
2
4
2
3
4
En effet, il y a deux ar etes qui partent de v
1
, lune vers v
2
et lautre vers v
4
, et les el ements de la
premi` ere liste (qui correspond ` a v
1
) sont donc 2 et 4.
La deuxi` eme liste correspond ` a v
2
qui a le seul voisin v
4
. Donc 4 est le seul el ement de la
deuxi` eme liste. Aucune ar ete ne part de v
4
, la quatri` eme liste est donc vide.
Remarquons nalement quon a 4 listes car le graphe a 4 sommets, et ces 4 listes sont stock ees
dans un array.
Avantages:
N ecessite peu de m emoire O([V [ +[E[).
On peut dynamiquement adapter le nombre dar etes.
D esavantages:
M emoire utilis ee en plus par les pointeurs.
Peut seulement op erer sur la liste dadjacence de mani` ere s equentielle (quoique ceci est
souvent sufsant).
En utilisant une liste dadjacence au lieu dun array il est aussi possible daugmenter ou de
diminuer le nombre de sommets du graphe. N eanmoins, dans ce cas il est impossible davoir un
acc` es al eatoire (random access) aux sommets.
3.3.2 Arbres
Les arbres sont lune des plus importantes structures de donn ees en informatique. Ils sont partic-
uli` erement utiles pour la repr esentation de donn ees hi erarchiques qui apparaissent dans beaucoup
dapplications. Tr` es souvent, les arbres forment la base de solutions algorithmiques efcaces de
probl` emes.
Exemples:
59
Arbres de d ecision
Arbres de syntaxe
Arbres de code
Arbres de recherche
Arbres couvrants (spanning trees)
Arbres binaires
Arbres AVL
Arbres bicolores
D enition. Un arbre est un graphe qui est connexe et sans cycles.
Nous consid erons surtout les arbres avec racine (rooted trees), cest-` a-dire un arbre avec un
sommet x e appel e sa racine (root).
On a:
Il existe pour tout v V exactement un chemin sans r ep etitions de la racine v
0
` a v.
(Preuve?)
Si le chemin la racine ` a v est de longueur r, nous disons que v a profondeur r.
Par d enition, la racine est lunique sommet de profondeur 0.
La notion de profondeur induit une structure hi erarchique sur larbre. Si x est un sommet
de profondeur r et y
1
, . . . , y
d
sont ses voisins de profondeur r + 1, alors on les appelle les
ls (children) de x, et x sappelle le p` ere (parent) des y
1
, . . . , y
d
. Lentier d sappelle le
degr e de x et est not e deg(x) (donc le degr e de x est le nombre de ls de x).
Un sommet de degr e 0 est appel e une feuille
Un sommet de degr e > 0 est appel e un sommet int erieur.
Le maximum max
vV
deg(v) sappelle le degr e de larbre.
La hauteur dun arbre est la plus grande profondeur dans larbre.
Pour nous, un nud est la m eme chose quun sommet.
60
Si T est un arbre et x un sommet de T, alors le sous-arbre de racine x est larbre form e de
tous les d escendants de x avec les m emes ar etes.
Bien que nous avons d eni un arbre comme un type particulier de graphe (connexe et sans
cycles), les d enitions ci-dessus ne sont pas les m emes que celles pour un graphe (par exemple le
d enition de degr e). Il est donc important quand on regarde des arbres avec racine de shabituer
` a ces d enitions.
Exemple: Consid erons larbre avec racine T ci-dessous:
x
y
1
y
2
y
3
v
racine
sommets int erieurs
Feuilles
On a les faits suivants:
T a hauteur 4
x a profondeur 1
y
1
, y
2
et y
3
ont tous profondeur 2
v a profondeur 1
x a degr e 3
y
1
et y
3
ont degr e 0, ce sont donc des feuilles
y
2
et v ont degr e 2
x est le p` ere de y
1
, y
2
et y
3
y
1
, y
2
et y
3
sont les ls de x
x et v sont les ls de la racine
61
La racine est le p` ere de x et v
le degr e de T est 3
La partie gris ee est un sous-arbre de T de racine v. Appelons ce sous-arbre B.
B a hauteur 2
B a degr e 3
En consid erant chaque ls de la racine comme racine dun autre arbre avec racine, nous
pouvons donner une d enition r ecursive dun arbre avec racine:
D enition. (Arbre avec racine)
1. Larbre vide (sans sommets) est un arbre avec racine.
2. Si d 0, T
1
, . . . , T
d
sont des arbres avec racine, et x est un nouveau sommet, alors T est
un arbre avec racine x.
T :=
x
T
1
T
2
T
d
Remarque: Avec la d enition ci-dessus, la notion darbre avec racine a et e etendue et inclut
maintenaut aussi les arbres vides et les sous-arbres vides.
Dhabitude, lordre des sous-arbres dun arbre avec racine nest pas important. Si lordre est
important, on dit que larbre est ordonn e. Par exemple, les deux arbres suivants
a
b b
a
ne sont pas distincts si consid er es comme des arbres non-ordonn es, mais il le sont en tant
quarbres ordonn es.
62
3.3.3 Representation darbres
Un arbre est un type particulier de graphe. On peut appliquer les m emes techniques pour
repr esenter des arbres que celles pour repr esenter des graphes.
Cependant la repr esentation par matrice dadjacence est tr` es inefcace: larbre sur n sommets
a seulement n1 ar etes, mais la matrice dadjacence utilise O(n
2
) bits. De plus, une ligne enti` ere
de la matrice doit etre parcourue pour trouver les ls dun sommet.
Les listes dadjacence sont mieux adapt es pour repr esenter des arbres. N eanmoins, avec cette
repr esentation, il est difcile de trouver le p` ere dun sommet donn e, parce que ceci nous oblige
a parcourir toutes les listes dadjacence.
Dans cette partie, nous etudierons dautres possibilit es pour repr esenter les arbres.
Nous supposerons que larbre en question est de degr e d (pour un d petit). Cest souvent vrai
en pratique. Par exemple, pour les arbres binaires on a d = 2.
Structures de Pointeurs
Comme les listes, les arbres peuvent aussi etre repr esent es en munissant chaque sommet avec
des pointeurs sur les voisins: chaque sommet est une structure (record, struct) qui, en plus des
donn ees stock ees au sommet, contient aussi des pointeurs vers le p` ere et tous les ls. Si larbre
est de degr e d, alors cette repr esentation peut etre r ealis ee en C++ comme suit:
struct node
int val;
node
*
parent;
node
*
child[d];
;
typedef node
*
tree;
Avec cette repr esentation, un arbre avec racine est donn e par un pointeur vers sa racine.
Exemple: Un arbre binaire
63
1
2 3
4 5 6
(Il est important davoir une liste doublement li ee pour etre capable dacc eder aux p` eres
directement.)
Avantages:
Repr esentation simple
Stockage dynamique
Insertion, effacement, d eplacement de sommets ou m eme de sous-arbres est tr` es efcace.
D esavantages:
N ecessite plus de m emoire pour les pointeurs.
Arbres comme tableaux (arrays)
Pour chaque sommet, on stocke les donn ees et les indices des ls/p` eres dans un tableau (array).
Cette m ethode est raisonnable seulement si le nombre de sommets de larbre nexc` ede pas un
maximum pr ed etermin e. Une telle repr esentation peut etre impl ement e en C++ de la mani` ere
suivante:
64
typedef int tree;
struct node
int val;
tree left;
tree right;
;
node table[MaxNodes+1];
Une valeur dindice de 1 correspond ` a un arbre vide. Ainsi, larbre est donn e par un tableau,
et lindice de sa racine se trouve dans le tableau.
Avantages:
Acc` es rapide
Pas de pointeurs
Il est possible d ecrouler larbre
D esavantages:
Nombre xe de sommets (structure statique)
Les op erations au milieu de larbre (telles que insertion et effacement) sont plus elabor ees
que pour le cas darbre bas e sur les pointeurs.
Exemple: Arbre dexpression
Consid erons lexpression
((a (a +b))) + (a +b).
On peut la repr esenter avec un arbre binaire de la mani` ere suivante:
65
B :
+
a +
a
b
+
a
b
0
1 2
3 4 5
6 7
8 9
Dans cet arbre la racine correspond ` a lindice 0. Larbre peut etre r ealis e par ce tableau
(array):
i val gauche droite
0 + 1 2
1 1 3
2 + 4 5
3 6 7
4 a 1 1
5 b 1 1
6 a 1 1
7 + 8 9
8 a 1 1
9 b 1 1
Par exemple, la premi` ere ligne du tableau nous dit que la racine (le sommet dindice 0) a la
valeur +, et que ses deux ls ont les indices 1 (gauche) et 2 (droite). Donc si on veut voir le ls
gauche du sommet on regarde la deuxi` eme ligne du tableau (puisque ce sommet a lindice 1) et
on voit que sa valeur est et que ses ls sont larbre vide (qui correspond ` a lindice 1) et le
sommet dindice 3.
Repr esentation implicite darbres
Les sommets sont stock es dans un array, les ar etes sobtiennent de mani` ere implicite par la
position des sommets dans larray. Supposons que larbre est de degr e d 2: La racine se
trouve en A[0]. Si x est stock e dans A[i], alors les enfants y
1
, . . . , y
d
de x sont stock es dans
A[di + 1], A[di + 2], . . . , A[di +d].
Avantage: Pas de pointeurs. Utilise peu de m emoire.
D esavantage: La m emoire est gaspill ee si larbre est pench e (i.e., il y a des sommets avec des
sous-arbres de tailles diff erentes). De plus, les op erations au milieu de larbre sont compliqu ees.
66
Exemple:
0
1
5
13
29
61
2
6
14
30
Nous avons besoin dun array avec 62 positions pour pouvoir repr esenter un arbre non-
equilibr e avec seulement 10 sommets.
3.3.4 Parcourir des arbres
Une fois les donn ees stock ees dans un arbre, nous aimerions pouvoir linspecter pour trouver des
sommets avec des propri et es donn ees ou pour appliquer une op eration ` a tous les sommets. Pour
ce faire, il est n ecessaire davoir des m ethodes syst ematiques pour parcourir larbre.
Nous consid erons ici le cas des arbres binaires ordonn es. Il y a trois m ethodes de parcours:
La m ethode preorder consiste ` a dabord parcourir la racine, ensuite le sous-arbre de gauche,
et nalement le sous-arbre de droite. (Cette d enition, comme les deux suivantes, est
r ecursive: Nous supposons que les sous-arbres gauche et droite sont aussi parcourus en
preorder.)
Le parcours inorder parcourt dabord le sous-arbre de gauche, ensuite la racine et enn le
sous-arbre de droite.
Parcourir larbre en postorder veut dire de dabord parcourir le sous-arbre de gauche, puis
le sous-arbre de droite, et nalement la racine.
Exemple: Les nombres dans les arbres ci-dessous donnent les ordres de parcours
1
2
3
4 5
6
7 8
9 10
11
12 13
10
4
3
1 3
6
5 8
7 9
12
11 13
13
9
3
1 2
8
4 7
5 6
12
10 11
preorder inorder postorder
67
Exemple: Nous repr esentons ici un arbre par un pointeur sur un struct qui contient comme
attributs un pointeur left et un pointeur right sur les sous-arbres de gauche et de droite
respectivement. Un pointeur NULL repr esente un arbre vide.
Lalgorithme r ecursif 17 effectue un parcours preorder. Dans cet exemple, inspect(t) effectue
Algorithme 17 preorder(t)
Input: Un pointeur t sur la racine a parcourir.
if t ,= NULL then
inspect(t)
preorder(left[t])
preorder(right[t])
end if
lop eration d esir ee sur le sommet t.
3.3.5 Resume de la section 3.3
Nous avons vu quun graphe etait une paire (V, E) o` u V est un ensemble de sommets et
E V V est une relation sur ces sommets. Nous avons vu les notions de chemin, cycle,
connexit e, in-degr e, out-degr e, graphe orient e, graphe non orient e.
Nous avons vu deux facons de repr esenter un graphe sur un ordinateur:
Par une matrice dadjacence
Par une liste dadjacence
Nous avons etudi e le concept darbre avec racine, et les notions de profondeur, hauteur,
degr e (notion diff erente que celle dun graphe en g en eral), ls, p` ere, feuille.
Nous avons vu la d enition de lindice dun sommet dans un arbre avec racine.
Nous avons vu plusieurs facons de repr esenter un arbre sur un ordinateur:
Par une structure de pointeurs
Sous forme de tableau
De facon implicite
Nous avons vu trois m ethodes pour parcourir un arbre binaire: preorder, inorder et pos-
torder.
68
3.4 STRUCTURES DE DONN
EES POUR DES ALGORITHMES

DE RECHERCHE
Le probl` eme que nous traiterons dans cette section consiste ` a trouver les el ements dans une base
de donn ees qui satisfont un certain crit` ere (appel e le crit` ere de recherche). Par exemple, la base
de donn ees pourrait etre un dictionnaire, dans lequel nous voulons trouver la d enitinon dun
mot. Il pourrait aussi sagir dun bottin, o` u nous voulons trouver le num ero de t el ephone de
quelquun (dont nous connaissons le nom). Dautres exemples:
Une table de symboles (dun compilateur).

Etant donn e le nom dune variable, trouver les
donn ees correspondantes.
Num eros de compte
Donn ees personnelles
Nous supposerons que linformation est d etermin ee de facon unique par une cl e k. Pour
lexemple du bottin, la cl e est le nom de la personne, et toutes les personnes auront, pour nous,
des noms distincts.
Il y a deux diff erents types dalgorithmes de recherche. Les algorithmes de recherche interne
travaillent sur une base de donn ees qui est en m emoire (RAM) et accessible. Les algorithmes de
recherche externe op` erent sur une base de donn ees dont une partie des donn ees se trouve sur un
m edia secondaire.
Par exemple, la m ethode de la recherche binaire, comme nous lavons vu au chapitre 0 est
un exemple typique dun algorithme de recherche interne. Un autre exemple important est la
recherche avec les arbres binaires que nous etudierons dans cette section plus en d etail.
Un algorithme de recherche externe typique est la recherche en utilisant les arbres B(B-trees),
mais ces arbres ne seront pas etudi es dans ce cours.
3.4.1 Arbres binaires de recherche
On peut stocker des donn ees dans un arbre binaire en associant ` a chaque sommet une entr ee de
la base de donn ees. Il est alors possible de retrouver une entr ee arbitraire en faisant un parcours
de larbre et en inspectant chaque sommet. Mais cette mani` ere de proc eder est O(n) et donc tr` es
lente, et en effet lint er et des arbres est quon peut utiliser leur structure darbre si les entr ees
sont stock es de mani` ere ordonn ee.
Arbres de recherche
D enition. Un arbre binaire de recherche est un arbre ordonn e binaire B muni dune indexation
des sommets S: V M, o` u M est un ensemble ordonn e de cl es (e.g., M = N
0
) tel que pour
69
tout k V , on a
S(k) > S() si sous-arbre gauche de k
S(k) < S(r) si r sous-arbre droit de k.
S(k)
< >
Exemple: Larbre suivant est un arbre binaire de recherche.
7
5
3 6
8
9 6
Les op erations que nous aimerions pouvoir effectuer rapidement dans un arbre de recherche
sont:
Search(x): Trouver la cl e x ou montrer que x ne se trouve pas dans la base de donn ees.
Insert(x): Ins erer x dans larbre de recherche sil nexiste pas encore.
Delete(x): Effacer x de larbre de recherche si x est un membre.
Sur un arbre binaire de recherche, ces algorithmes peuvent etre r ealis es comme suit:
Recherche (Search): La recherche est une proc edure r ecursive tr` es simple.
Sil sagit de larbre vide, la recherche echoue (x ne se trouve pas dans larbre)
Sinon on compare x avec la cl e r de la racine:
Si x = r, on a ni; on a trouv e le sommet r cherch e.
Si x < r, on cherche pour x dans le sous-arbre de gauche.
Si x > r, on cherche dans le sous-arbre droite.
70
Par exemple, pour chercher la cl e 6 dans larbre exemple ci-dessus, on commence ` a la racine
et on visite, un apr` es lautre, les sommets comme indiqu e par la ` eche:
7
5
3 6
8
9 6
Insertion (Insert): On commence en faisant une recherche de x. Si on trouve x alors quil
est d ej` a dans larbre et on ne doit donc plus rien faire. Si on ne le trouve pas (i.e. la recherche
echoue), lalgorithme se terminera sur une feuille. Appelons b la cl e de cette feuille.
Si x < b, on ajoute un sommet gauche de cette feuille, et on le munit de la cl e x.
Sinon, on ajoute un sommet droite ` a cette feuille, et on le munit de la cl e x.
Exemple dinsertion: On ins` ere 3, 1, 4, 7, 6, 2, 5 dans un arbre initialement vide.
3
3
1
3
1 4
3
1 4
7
3
1 4
7
6
3
1
2
4
7
6
3
1
2
4
7
6
5
Effacement (Delete): On commence comme pour Search(x). Si la recherche echoue, x ne
se trouve pas dans larbre et nous navons donc plus rien ` a faire. Si x se trouve dans larbre, nous
d eterminons ainsi sa position.
Nous aimerions enlever x sans perdre la propri et e de larbre de recherche.
Cest facile si x est une feuille ou si x na quun seul ls, il suft dans ce cas deffacer le
sommet correspondant, et de mettre lunique ls ` a sa place (ou larbre vide sil en a pas).
Illustration:
71
a
x
y
a
y
a
x
y
a
y
Dans le cas g en eral, si x a deux ls, effacer est plus difcile.

Ecrivons la racine du sous-
arbre gauche de x et r la racine du sous-arbre droite.
Soit y le sommet quon trouve en commencant en et en passant toujours au sous-arbre droite
jusqu` a ce quil ny en a plus.
x
r
y
r
Alors, comme y se trouve dans le sous-arbre gauche de x, nous avons y < x. Dautre part, y
est le plus grand el ement du sous-arbre gauche de x (pourquoi ?). Ayant trouv e y, nous pouvons
effacer x comme suit:
Delete(x): Remplacer x par y, et remplacer y par son sous arbre de gauche.
En proc edant de cette mani` ere la propri et e de larbre de recherche est pr eserv ee, comme < y <
r
pour nimporte quel sommet r
du sous-arbre de droite.
Analyse du temps de parcours. Les temps de parcours des op erations consid er ees ci-dessus
d ependent de la forme de larbre de recherche et de la position du sommet en question.
Dans le pire des cas, les temps de parcours sont proportionnels ` a la hauteur de larbre. La
hauteur dun arbre binaire avec N sommets est entre log
2
(N) et N 1. Donc, le co ut des
op erations est O(N) dans le pire des cas.
72
En ce sens, les arbres de recherche sont tr` es similaires ` a des structures de donn ees beaucoup
plus simples telles que par exemple un tableau avec la recherche s equentielle: cette derni` ere
structure permet aussi deffectuer toutes ces op erations en O(N).
Naurions-nous donc rien gagn e par rapport ` a des structures de donn ees bien plus simples
(telles quune liste li ee avec recherche s equentielle)? La r eponse est quen pratique on ne
sint eresse pas seulement au comportement dans le pire des cas, mais aussi au comportement
en moyenne. Nous verrons maintenant quen moyenne, les arbres de recherche se comportent en
fait bien mieux que par exemple une liste li ee pour ces op erations.
De quoi devrions-nous prendre la moyenne?
Analyse de larbre al eatoire. Nous supposons que les N! facons dordonner N cl es ont toutes la
m eme probabilit e et nous consid erons larbre de recherche obtenu en ins erant les cl es 1, 2, . . . , N
dans un ordre al eatoire dans un arbre vide. Nous prenons donc la moyenne sur tous les N! arbres
de recherche correspondant aux ordres possibles des cl es.
Par exemple, si est la permutation
_
123
312
_
, larbre de recherche correspondant est
3
1
2
=: B().
Soit B = (V, E) un arbre de recherche de sommets v
1
, . . . , v
N
et de cl es correspondantes
1, 2, . . . , N. Nous d enissons
A
B
=
N
k=1
#Recherches pour trouver k
=
N
k=1
(profondeur(v
k
) + 1).
Soit S
N
lensemble de toutes les permutations sur N sommets, et pour S
N
soit B()
larbre de recherche correspondant. Alors
E
N
:=
1
N!
S
N
A
B()
est la moyenne du nombre total de recherches dans un arbre al eatoire de recherche. Est-il possible
de trouver une formule plus explicite pour E
N
?
Pour E
0
, E
1
, nous avons
E
0
= 0
E
1
= 1.
Nous aimerions trouver une formule inductive pour E
N
. Lillustration dun arbre binaire de
racine k suivante nous donne une id ee:
73
k
L R
Notons pour le moment E
N,k
la moyenne du nombre total de recherches dans un arbre de
recherche de racine k. Nous avons
E
N,k
= N +E
k1
+E
Nk
,
et donc, comme tout sommet k 1, . . . , N a m eme probabilit e d etre racine dun arbre
al eatoire de recherche ` a N sommets,
E
N
=
1
N
_
N
k=1
N +E
k1
+E
Nk
_
= N +
1
N
_
N1
k=0
E
k
_
+
1
N
_
N1
k=0
E
k
_
= N +
2
N
N1
k=1
E
k
Pour N + 1, la formule ci-dessus se r e ecrit
E
N+1
= (N + 1) +
2
N + 1
N
k=1
E
k
.
Donc
(N + 1)E
N+1
= (N + 1)
2
+ 2
N
k=1
E
k
NE
N
= N
2
+ 2
N1
k=1
E
k
= (N + 1)E
N+1
NE
N
= 2N + 1 + 2E
N
Cette derni` ere equation nous donne la formule r ecursive suivante:
E
0
= 0
E
1
= 1
E
N+1
=
N + 2
N + 1
E
N
+
2N + 1
N + 1
.
74
Ecrivons
H
N
:= 1 +
1
2
+
1
3
+. . . +
1
N
le N
` eme
nombre harmonique. Nous avons alors
E
N
= 2 (N + 1) H
N
3N.
Or, pour H
N
nous disposons de lapproximation suivante:
H
N
= ln N + +
1
2N
+O
_
1
N
2
_
(o` u = 0.5772 . . . est la constante dEuler). Ceci nous donne pour E
N
:
E
N
= 2N ln N (3 2)N + 2 lnN + 1 + 2 +O
_
1
N
2
_
.
Enn donc,
E
N
N
1.386 . . . log
2
N (3 2) +
2 lnN
N
+. . .
est le nombre moyen de recherches pour un sommet al eatoire dans un arbre binaire de recherche
avec N sommets. Ceci prouve le th eor` eme suivant:
Th eor` eme 3.1 Dans un arbre de recherche choisi al eatoirement, linsertion et leffacement peu-
vent etre effectu es en moyenne avec O(log
2
(N)) op erations.
Nous insistons sur le fait que le th eor` eme ci-dessus ne nous donne que le comportement
darbres de recherche en moyenne. Dans le pire des cas, les temps de parcours peuvent etre
O(N), ce qui est beaucoup plus grand.
Pour un arbre complet binaire (le meilleur cas), la moyenne correspondante est egale ` a
N+1
N
log
2
(N + 1) 1. (Sans preuve.) Si N est grand, nous avons
N+1
N
1 < 1.39, et donc
lop eration de recherche prend en moyenne 40% de temps en plus dans un arbre al eatoire que
dans un arbre complet.
3.4.2 Arbres bicolores
Bien quon puisse en moyenne faire des recherches dans un arbre binaire de facon rapide, ils se
comportent tr` es mal dans le pire des cas. En effet le temps de parcours dune recherche d epend
de la hauteur de larbre, qui sera O(N) dans le pire des cas. Le probl` eme est que si les el ements
sont ins er es dans un certain ordre (par exemple de facon croissante), la hauteur de labre grandit
tr` es vite.
75
Intuitivement, les arbres bicolores sont des arbres binaires de recherche dont la hauteur nest
pas trop grande, pour lesquels on peut ajouter et enlever des el ements en maintenant cette pro-
pri et e.
D enition. Un arbre bicolore (red-black tree) est un arbre binaire de recherche dans lequel
chaque sommet est attribu e une couleur, soit rouge ou soit noir. De plus les conditions suivantes
doivent etre v eri ees:
1. La racine est noire.
2. Les ls dun sommet rouge sont noirs.
3. Tout chemin dun sommet ` a une de ses feuilles contient le m eme nombre de sommets noirs.
Remarquons que la deuxi` eme condition est equivalente ` a dire que le p` ere dun sommet rouge
est toujours noir.
Proposition 3 Dans un arbre bicolore, le sommet le plus profond est au plus deux fois plus
profond que le sommet le moins profond.
Preuve: Puisque les ls dun sommet rouge sont tous noirs (condition 2 dans la d enition dun
arbre bicolore), un chemin de la racine ` a une feuille ne peut pas contenir deux sommets rouges
de suite. Si un tel chemin contient m sommets noirs, il contiendra donc au plus 2m sommets au
total (en alternant la couleur des sommets le long du chemin).
Nous avons de plus (condition 3) que tous les chemins de la racine ` a une feuille contiennent le
m eme nombre de sommets noirs. Si nous appelons m ce nombre, nous voyons quun tel chemin
contiendra au total au moins m et au plus 2m sommets. Puisque la profondeur dun sommet est
la longueur du chemin de la racine ` a ce sommet, le r esultat suit imm ediatement.
Cette propri et e garantit que la hauteur dun arbre bicolore nest pas trop grande.
Insertion
Nous commencer par ajouter le sommet de la m eme facon que dans un arbre binaire normal,
et le colorons en rouge. Soient x le sommet ajout e, soit y sont p` ere, soit z sont grand-p` ere, et soit
u sont oncle.
Cas 1: x est la racine. Nous colorons x en noir.
Cas 2: y est noir. Nous ne faisons rien.
Cas 3: y est rouge, et u est rouge. Nous colorons y et u en noir.
76
Cas 4: y est rouge, u est noir, et x est le ls de droite de y. Nous faisons une rotation ` a
gauche.
Cas 5: y est rouge, u est noir, et x est le ls de gauche de y. Nous faisons une rotation ` a
droite.
Nous devons ` a pr esent v erier que dans chaque cas, les 3 propri et es de la d enition ci-dessus
restent vraient apr` es linsertion. Il est clair que la propri et e 1 restera vraie. Nous regardons ` a
pr esent les deux propri et es restantes:
Cas 1: Larbre na quun seul sommet noir, toutes les propri et es sont donc v eri ees.
Cas 2: Nous avons ajout e un sommet dont le p` ere est noir, la propri et e 2 reste donc vraie.
De plus, le chemin dun sommet quelconque t vers x aura le m eme nombre de sommets
noirs que le chemin de t vers y, la propri et e 3 est donc toujours v eri ee.
Cas 3:
Cas 4:
Cas 5:
Effacement
Cas 1: x est la racine. Nous ne faisons rien
Cas 2: z est rouge. Nous colorons z en noir, y en rouge puis faison une roation ` a gauche
en y.
Cas 3:
Cas 4:
Cas 5:
3.4.3 Arbres AVL
Les arbres de recherche binaires se comportent tr` es mal dans le pire des cas, parce quils peuvent
etre tr` es pench es.
Un arbre binaire est dit equilibr e (balanced), ou appel e arbre AVL (dapr` es Adelson, Velskij
et Landis), si pour tout sommet k les hauteurs des sous-arbres gauches et droits diff` erent par au
plus 1.
77
D enition. Soit T un arbre binaire avec racine. Soit v
k
un sommet de T. Le facteur d equilibre
(balance factor) de v
k
est d eni comme suit:
bal(v
k
) = (hauteur du sous arbre de gauche) (hauteur du sous arbre de droite),
o` u nous supposons quun sous arbre vide a hauteur 1.
D enition. Un arbre AVL est un arbre binaire avec racine dans lequel le facteur d equilibre de
chaque sommets vaut 1, 0, ou 1.
Exemple: Le graphique suivant repr esente un arbre AVL dans lequel les sommets sont index es
par leurs facteurs d equilibre respectifs.
1
1
1 0
0
1
0
La propri et e principale dun arbre AVL est que sa hauteur ne peut crotre que logarithmique-
ment avec le nombre de sommets. Un arbre AVL avec N sommets permet donc de chercher,
dins erer et deffacer en O(log N) op erations dans le pire des cas.
Th eor` eme 3.2 La hauteur dun arbre AVL avec n sommets v erie lin egalit e suivante:
h < 1.4404 log
2
(n) + 0.672.
Preuve. Remarquons dabord que les sous-arbres darbres AVL sont eux-m emes des arbres AVL.
Quel est le nombre minimal de sommets dans un arbre AVL de hauteur h?
78
Pour h = 1, 2 nous avons:
h = 1: 2
h = 2: 4
En g en eral, il y a trois cas: bal(racine) = 1, 0, 1.
h h
bal=0
h
h + 1
h + 1
h
bal=+1
h + 2
h + 1
h
bal=1
h + 2
Le nombre minimum A
h
de sommets dans un arbre AVL de hauteur h v erie
A
h+1
= 1 + min (2A
h
, A
h
+A
h1
)
= 1 +A
h
+A
h1
.
Nous prouvons par induction que
A
h
>
1 +
5
2
5
_
1 +
5
2
_
h
. (3.2)
[Base] Pour h = 1, on a A
h
= 2 >
(1+
5)
2
4
5
.
[Pas] Posons c :=
1+
5
2
5
.
A
h+1
= 1 +A
h
+A
h1
> 1 +
1 +
5
2
5
_
1 +
5
2
_
h
+
1 +
5
2
5
_
1 +
5
2
_
h1
= 1 +c
_
1 +
5
2
_
h _
1 +
2
1 +
5
_
= 1 +c
_
1 +
5
2
_
h
3 +
5
1 +
5
> c
_
1 +
5
2
_
h+1
.
79
Donc par induction (3.2) est vraie.
Si on pose b =
1+
5
2
, on sait ` a pr esent (par (3.2)) quun arbre AVL de hauteur h doit avoir au
moins c b
h
sommets. Supposons maintenant que nous avons un arbre AVL avec n sommets, et
soit h sa hauteur, par la phrase pr ec edente on doit avoir
c b
h
< n b
h
<
n
c
h log(b) < log(n) log(c)
h <
log(n)
log(b)

log(c)
log(b)
= h < 1.4404 log
2
(n) + 0.672
Ce th eor` eme nous dit que la hauteur dun arbre AVL avec N sommets est O(log(N)).
Lop eration Search co ute donc O(log(N)), m eme dans le pire des cas. Cependant, avec les
m ethodes dinsertion et deffacement que nous avons vues pour les arbres binaires de recherche,
si nous ajoutons ou effacons un el ement dun arbre AVL il ne sera plus n ecessairement AVL.
Si nous pouvions ins erer et effacer des sommets dun arbre AVL avec N sommets en temps
O(log(N)) en maintenant la condition AVL, alors nous aurions une structure de donn ees qui
permettrait deffectuer les op erations dinsertion, deffacement et de recherche en O(log(N)),
dans le pire des cas. De telles m ethodes dinsertion et deffacement existent, elles sont d ecrites
ci-dessous:
Insertion: On commence par ins erer le sommet de la m eme mani` ere que dans un arbre de
recherche binaire. Ensuite, lalgorithme remonte du sommet ins er e jusqu` a la racine en v eriant
l equilibre ` a chaque sommet du chemin. Si un sommet non- equilibr e est rencontr e (i.e., tel que
le facteur d equilibre est egal ` a +2 ou -2), alors une rotation est effectu ee. Le type de rotation ` a
effectuer d epend de la position du sommet ins er e par rapport au sommet non- equilibr e.
Toutes les congurations possibles peuvent se classer en 4 cas, pour chacun desquels il existe
une rotation qui r e equilibre le sommet. Les 4 rotations sont appel ees RL, LR, RR et LL:
80
Rotation RL:
Rotation LR:
Rotation RR:
Rotation LL:
81
Exemple: Voici une illustration de la proc edure de r e equilibrage. Le sommet bleu (new node)
vient d etre ajout e, et larbre nest donc plus AVL. Il faut effectuer une rotation pour le r e equilibrer.
2
0
0 0
2
0 +1
1
0
0
New node
Nous suivons le chemin du sommet ajout e ` a la racine jusquau prochain sommet non- equilibr e
(dans lexemple le sommet rouge, qui a comme facteur d equilibre 2). Ce sommet subira une
rotation RL:
1
0
0 0
0
+1 0
0 0 0
Effacement: Lalgorithme deffacement est un peu plus compliqu e. On commence par effacer
le sommet comme dans un arbre binaire de recherche arbitraire (cest-` a-dire non AVL). Comme
pour linsertion, larbre doit ensuite etre r e equilibr e en utilisant des rotations. Nous illustrons
cette proc edure ` a laide dun exemple.
Exemple: Dans larbre ci dessous supposons que nous voulons effacer le sommet dont la cl e vaut
26 (que nous appelons simplement le sommet 26). Lalgorithme deffacement que nous avons
d ej` a vu (pour les arbres non AVL) enl` eve le sommet 26 et le remplace par le sommet 23:
26
19
17
11
23
39
30
27 37
42
82
Nous voyons ensuite que larbre nest plus equilibr e (il nest plus AVL), puisque le facteur
d equilibre du sommet 19 vaut +2.
23
19
17
11
39
30
27 37
42
Rotation LL
On voit maintenant, en regardant les diagrames ci-dessus que cette conguration peut etre
r e equilibr ee avec une rotation LL:
23
17
11 19
39
30
27 37
42
Quelques remarques:
Contrairement au cas dinsertion, il est possible que plusieurs rotations soient n ecessaires
pour le r e equilibrage apr` es un effacement.
Le co ut des op erations dinsertion et deffacement est O(log(N)), o` u N est le nombre total
de sommets. Nous ne prouverons pas ce r esultat.
Remarquons pour terminer quune impl ementation efcace dun arbre AVLn ecessite quon
stocke quelque chose de plus dans chaque sommet, ` a savoir le facteur d equilibre: On ne
peut pas se permettre de le recalculer ` a chaque fois quon v erie l equilibre.
3.5 LE HACHAGE (HASHING)
Nous avons vu des m ethodes pour stocker des donn ees permettant une impl ementation efcace
des operations de recherche, dinsertion et deffacement. Dans ces m ethodes, chaque el ement
est identi e par une cl e unique. Cependant, seul un petit sous-ensemble K de lensemble K de
toutes les cl es possibles nest utilis e ` a un moment donn e.
83
Les m ethodes vues jusqu` a pr esent proc` edent en comparant les cl es des el ements. Par contre,
les m ethodes de hachage (hash methods) tentent de trouver un el ement en calculant sa position
` a partir de sa cl e k. Les el ements sont stock es dans un tableau (array) lin eaire avec des indices
0, 1, . . . , m1, quon appelle la table de hachage (hash table).
D enition. La fonction de hachage (hash function) est une application
h: K 0, 1, . . . , m1,
qui fait correspondre ` a chaque cl e k un indice h(k), appel e ladresse de hachage (hash address).
Donc pour savoir o` u stocker un el ement avec cl e k dans la table de hachage, il suft de
calculer h(k) qui nous donnera lindice du tableau o` u mettre notre el ement. De m eme pour
rechercher un el ement on calcule son adresse de hachage h(k) puis on regarde la position corre-
spondante dans la table de hachage.
Cependant, mest en g en eral beaucoup plus petit que K. La fonction de hachage nest donc en
g en eral pas injective, cest-` a-dire que plusieurs cl es peuvent avoir la m eme adresse de hachage.
D enition. Soit h une fonction de hachage, et soient k, k
K. Si
k ,= k
et h(k) = h(k
).
alors on dit quon a une collision dadresse (address collision), et k et k
sont appel es des syn-

onymes.
Une bonne m ethode de hachage doit avoir les propri et es suivantes:
Elle doit donner aussi peu de collisions dadresse que possible
Les collisions doivent etre r esolues de mani` ere efcace
Il doit etre possible de calculer lindice de hachage h(k) dune cl e de mani` ere efcace.
M eme les meilleures fonctions de hachage ne peuvent pas eviter les collisions. Les m ethodes
de hachage sont donc tr` es inefcaces pour linsertion et leffacement dans le pire des cas. Cepen-
dant elles sont en moyenne beaucoup meilleures que les m ethodes qui utilisent des comparaisons
de cl es. Par exemple, le temps de recherche en utilisant le hachage est ind ependant du nombre
d el ements stock es.
Les m ethodes de hachage doivent plut ot etre utilis ees quand les insertions sont toutes faites
initialement, et que les op erations sont ensuite presque exclusivement des recherches, et sans que
des el ements ne soient effac es.
84
Les m ethodes de hachage introduites dans ce cours sont seulement semi-dynamiques, puisque
les tables de hachage sont x ees au d ebut.
Nous nous int eressons aux temps de parcours moyens des op erations de recherche, dinsertion
et deffacement, puisque les temps de parcours dans les pires des cas sont tr` es mauvais.
D enition. Pour mesurer la performance dune m ethode de hachage on d enit:
C
n
= Esp erance du nombre dentr ees visit ees dans une table de hachage lors dune
recherche r eussie
C
n
= Esp erance du nombre dentr ees visit ees dans une table de hachage lors dune
recherche qui echoue
Nous indiquerons toujours les distributions de probabilit e qui nous int eressent.
Une bonne fonction de hachage doit avoir les propri et es suivantes:
Elle doit etre calculable de mani` ere efcace,
Elle doit distribuer les el ements de mani` ere uniforme, m eme si les cl es ne le sont pas (par
exemple des noms de variables dans un programme)
M eme dans le meilleur des cas il est impossible d eviter les collisions.
Birthday Lemma. Si q 1.78
_
[M[, alors la probabilit e quune fonction al eatoire uniforme
f : 1, 2, . . . , q M
soit injective est inf erieure ` a 1/2.
Corollaire. Si plus de 23 personnes sont dans une pi` ece, alors la probabilit e quau moins deux
dentre elles aient le m eme anniversaire est sup erieure ` a 1/2.
Preuve du Birthday Lemma: On pose m = [M[. La probabilit e que la fonction soit injective
est
m(m1)(mq+1)
mmm
=
_
1
1
m
_

_
1
q1
m
_
< e
q(q1)
2m
Si q
1+
1+8 ln(2)
2

m, on a
e
q(q1)
2m
<
1
2
.
85
Remarquons que
1+
1+8 ln(2)
2
1.78.
Nous supposons ` a partir de maintenant que lensemble K de toutes les cl es possibles est un
sous-ensemble de N. Si les cl es nous sont donn ees, par exemple sous la forme dune liste de
caract` eres (comme le nom dune variable en C), nous pouvons interpr eter les codes ASCII des
caract` eres comme des entiers positifs et ainsi faire correspondre ` a chaque liste de caract` eres un
entier.
La m ethode de division avec reste
Dans cette m ethode on choisit une valeur m qui sera la taille de la table de hachage. On
d enit la fonction de hachage f : K 0, 1, . . . , m1 comme suit:
h(k) := k mod m.
On a donc bien h(k) 0, 1, . . . , m1.
Le choix de m est crucial. Par exemple, si m est pair, alors le bit le moins signiant de k et
h(k) est le m eme (est en collision). On aura donc plus de collisions pour les el ements qui ont le
m eme bit le moins signiant. Avec le m eme raisonnement, on voit que m ne doit pas etre une
puissance de 2 puisque dans ce cas les el ements avec les m emes bits les moins signiants seraient
en collision. Plus concr` etement, si on choisissait m = 2
, alors les bits les moins signiants de

k et de h(k) seront les m emes.
On choisit dhabitude pour m une puissance dun nombre premier qui ne sexprime pas sous
la forme 2
j pour un certain et un certain j petit.

La m ethode multiplicative
La cl e est multipli ee par un nombre irrationel , puis on regarde la partie fractionnaire (apr` es
la virgule) du r esultat.
On obtient ainsi des r esultats diff erents pour diff erentes valeurs entre 0 et 1:
Si k k = , alors (k l) Z. Et puisque est irrationel, on a k = 0.
Le Th eor` eme suivant (de Vera Tur an S os) montre que pour les cl es 1, 2, 3, . . . , n ces valeurs
sont assez uniform ement distribu ees dans lintervalle [0, 1):
Th eor` eme 3.3 Pour un irrationnel, les sous-intervalles form es par les nombres
, 2 2 , . . . , n n
ont au plus trois longeurs diff erentes. De plus, le prochain point (n+1) (n + 1) sera dans
un de ces intervalles.
86
Parmi tous les avec 0 1 le nombre dor
1
=
5 1
2
0, 6180339887
donne la distribution la plus uniforme. On obtient la fonction de hachage
h(k) :=
_
m
_
k
1
_
k
1
___
En particulier, la suite h(1), h(2), . . . , h(10) pour m = 10 est simplement une permutation
des entiers 0, 1, . . . , 9: 6, 2, 8, 4, 0, 7, 3, 9, 5, 1.
Lum, Suen, et Dodd ont etudi e le comportement de nombreuses fonctions de hachage, et ont
r ealis e que la m ethode de division avec reste donne les meilleurs r esultats en moyenne.
Dans les discussion qui suivent sur la r esolution de collisions, nous supposerons donc tou-
jours que cest cette m ethode de hachage qui est utilis ee.
Les Strategies pour la R esolution de Collisions
Supposons que nous avons une table de hachage qui contient la cl e k. Si nous voulons ins erer
dans cette table un synonyme k
de k (i.e. une cl e avec h(k) = h(k
)), nous aurons alors une

collision dadresse quil faudra r esoudre.
La position de h(k) = h(k
) est d ej` a occup ee et la nouvelle cl e doit donc etre stock ee autre

part. De tels synonymes peuvent etre stock es hors de la table de hachage, dans des listes dy-
namiques. Par exemple, les synonymes dune cl e peuvent etre maintenus dans une liste li ee
lin eaire. Cette liste est connect ee ` a la position de la table de hachage donn ee par la valeur de
hachage des cl e synonymes.
Exemple: Soit
m = 7
la taille de la table de hachage (donc le nombre daddesses de hachage), soit
K = 0, 1, . . . , 500
lensemble des cl es possibles, et soit
h(k) = k mod m
la fonction de hachage.
Apr` es avoir entr e les cl es 12, 53, 5, 15, 2, 19, 43, la table de hachage est dans l etat suivant:
87
0

/
1
15

43
/
2
2
/
3

/
4
53
/
5
12

5

19
/
6

/
t:
Table de hachage
Synonymes
Avec cette m ethode chaque el ement de la table de hachage est le d ebut dune liste li ee.
La m ethode dadresse directe est plus facile ` a impl ementer, mais n ecessite plus de m emoire:
0
/
1

15

43
/
2

2
/
3
/
4

53
/
5

12

5

19
/
6
/ t:
Table de Hachage:
Pointeur
Synonymes actuels
Nous analysons ` a pr esent la m ethode dadresse directe. Nous supposons:
La fonction de hachage retourne les valeurs de hachage avec la m eme probabilit e (suppo-
sition de distribution uniforme)
88
Les valeurs de la fonction de hachage sont ind ependantes pour chaque op eration (supposi-
tion dind ependance)
La deuxi` eme supposition nous dit que la j
` eme
op eration choisit toujours ladresse j
avec
probabilit e 1/m, quel que soit j,
D enition. Si n est le nombre de cl es possibles et m la taille de la table de hachage, alors le
facteur doccupation est d eni comme suit:
:=
n
m
.
Analyse dune recherche qui echoue
Dans ce cas, ladresse h(k) est calcul ee, et tous les el ements dans la liste de synonymes sont
travers es.
La longueur moyenne de chaque liste est n/m = , et donc
C
n
=
Analyse dune recherche qui r eussit
Supposons quil faille visiter i el ements pour trouver la cl e recherch ee, i.e., le co ut de trouver
la cl e est i.
Quand nous ajoutons la j
` eme
cl e, la longueur moyenne de la liste est (j 1)/m; Donc, en
cherchant la j
` eme
cl e nous navons besoin de visiter que 1 + (j 1)/m el ements de la liste, si
les insertions dans la liste ne sont faites qu` a la n, et quil ny a aucun effacement. Le nombre
moyen de cl es visit ees dans le cas dune recherche r eussie est donc
C
n
=
1
n
n
j=1
_
1 +
j1
m
_
= 1 +
n1
2m
1 +

2
si chaque cl e est recherch ee avec la m eme probabilit e.
89
4
Construction dalgorithmes par
induction
La m ethode dinduction peut etre utilis ee pour construire des algorithmes, en r eduisant la reso-
lution dune instance dun probl` eme ` a la resolution dune ou plusieurs instances plus petites du
m eme probl` eme.
Deux points sont essentiels dans la conception dalgorithme par induction:
Il est possible de r esoudre une petite instance du probl` eme: le cas de base.
Une solution de chaque probl` eme peut etre construite ` a partir de solutions de plus petits
probl` emes: le pas dinduction.
Nous verrons des exemples de cette m ethode, et introduirons plusieurs classes dalgorithmes
bas ees sur cette m ethode, telles que la programmation dynamique et les algorithmes diviser-
pour-r egner (divide-and-conquer).
4.1 LA M
ETHODE DE HORNER
La m ethode de Horner est un algorithme efcace pour evaluer des polyn omes g en eriques en un
point donn e. Le probl` eme qui nous int eresse est donc le suivant:
Probl` eme: Evaluation de Polyn ome
Input: Polyn ome f(x) =
n
i=0
f
i
x
i
R[x], et R.
Output: f().
Lalgorithme qui suit pr esente une m ethode nave pour evaluer un polyn ome en un point
donn e.
90
Algorithme 18 NAIF(f(x), )
1: s 0 et i 0.
2: while i n do
3: Calculer
i
.
4: s s +f
i
.
5: i i + 1.
6: end while
7: return s
Si nous utilisons la m ethode nave pour calculer
i
` a la ligne 3, alors lalgorithme a besoin de
O(n
2
) op erations sur des nombres r eels. Si nous utilisons la m ethode binaire ` a la ligne 3, alors
lalgorithme a besoin de O(nlog(n)) op erations sur des nombres r eels.
Pouvons nous faire mieux? Oui. La m ethode de Horner simplie le probl` eme en utilisant
lobservation suivante:
f() = f
0
+g(),
o` u g(x) = f
1
+f
2
x + +f
n
x
n1
.
Nous utilisons donc le fait que f() est egal ` a
(( ((f
n
+f
n1
) +f
n2
) ) +f
1
) +f
0
.
En pseudo-code, nous d ecrivons la m ethode de Horner comme suit:
Algorithme 19 HORNER(f(x), )
1: s 0 and i n.
2: while i 0 do
3: s s +f
i
.
4: i i 1.
5: end while
6: return s
Sous cette forme nous voyons imm ediatement quil faut ` a cet algorithme n + 1 additions et
n + 1 multiplications pour calculer f() (nous ne comptons pas les op erations sur le compteur
i), ainsi nous avons un algorithme O(n).
La m ethode de Horner est-elle optimale? La r eponse est oui, pour des polym omes g en eriques
(preuve difcile). Pour des polyn omes sp eciques, la m ethode de Horner peut ne pas etre op-
timale (on peut, par exemple, evaluer le polyn ome f(x) = x
n
plus rapidement quen O(n)
op erations.)
91
4.2 ELIMINATION DE GAUSS
Supposons que nous voulons r esoudre un syst` eme d equations lin eaires. Formellement nous
avons:
Probl` eme: Syst` eme d equations lin eaires
Input: Matrice A R
nn
, vecteur b R
n
Output: Vecteur x R
n
tel que A x = b.
Lalgorithme pour r esoudre un tel syst` eme est tr` es utilis e en alg` ebre lin eaire. On lappelle la
m ethode du pivot de Gau. Nous la pr esentons ici dans le cadre des algorithmes construits par
induction en insistant sur le caract` ere inductif de lalgorithme.
Nous pouvons ecrire la matrice A par blocs de la mani` ere suivante :
A =
a
11
A
12
A
21
A
22
,
o` u a
11
R, A
12
R
1(n1)
, A
21
R
(n1)1
, et A
22
R
(n1)(n1)
.
Nous appelons a
11
le pivot, et supposons que a
11
,= 0. Soit I
m
la matrice identit e de dimen-
sion m. Alors
X
..
_
_
1 0
A
21
a
11
I
n1
_
_
A
Y
..
_
_
1
A
12
a
11
0 I
n1
_
_
=
Z
..
_
_
a
11
0
0

A
_
_
, (4.1)
o` u
A = A
22
A
21
a
1
11
A
12
. (4.2)
92
Cette matrice

Aest appel ee le compl ement de Schur de Apar rapport ` a a
11
. En utilisant X, Y
et Z denis ci-dessus nous avons:
A x = b X A x = X b
(X A Y ) Y
1
x = X b
Z Y
1
x = X b, (avec (4.1) ci dessus)
et nous obtenons donc le syst` eme d equations suivant:
_
_
a
11
0
0

A
_
_
_
_
1
A
12
a
11
0 I
n1
_
_
x =
_
_
1 0
A
21
a
11
I
n1
_
_
b. (4.3)
Denissons ` a pr esent
x =
_
_
_
_
_
x
1
x
2
.
.
.
x
n
_
_
_
_
_
, y =
_
_
_
_
_
x
2
x
3
.
.
.
x
n
_
_
_
_
_
, b =
_
_
_
_
_
b
1
b
2
.
.
.
b
n
_
_
_
_
_
, c =
_
_
_
_
_
b
2
b
3
.
.
.
b
n
_
_
_
_
_
.
En decomposant (4.3) nous voyons que
x
1
=
1
a
11
(b
1
A
12
y) (4.4)
A y = c
. (4.5)
o` u
c
=
b
1
a
11
A
21
+c. (4.6)
Ces identit es nous m` enent ` a lalgorithme suivant pour calculer x:
Analyse
Soit C
n
le nombre dop erations arithm etiques quil faut ` a cet algorithme pour r esoudre un
syst` eme de n equation ` a n inconnues (donc quand A est une matrice n n). Nous regardons
chaque etape de lalgorithme:
Calcul de

A (ligne 5): Nous savons que

A = A
22
A
21
a
1
11
A
12
(voir (4.2)). A
12
, A
21
et A
22
sont des sous-matrices de A elles sont donc toutes connues. Nous commencons par multiplier
A
12
par a
1
11
, il faudra (n 1) multiplications (puisque A
12
est un vecteur ` a (n 1) entr ees).
Ensuite nous multiplions le r esultat par A
21
, il faudra (n1)
2
multiplications (le r esultat est une
matrice (n 1) (n 1)). Finalement nous soustrayons le r esultat ` a A
22
, il faudra (n 1)
2
soustractions. Le nombre dop eration total est donc
(n 1) + (n 1)
2
+ (n 1)
2
= 2(n 1)
2
+ (n 1)
93
Algorithme 20 R ESOUDRE(A, b, n)
1: if n = 1 then
2: x
1

b
1
a
11
3: return (x
1
)
4: else
5: Calculer

A et c
6: y R ESOUDRE(

A, c
, n 1)
(donc trouver y = (x
2
, . . . , x
n
) tel que

A y = c
)
7: s A
12
y
8: x
1

1
a
11
(b
1
s)
9: return (x
1
, x
2
, . . . , x
n
)
10: end if
Calcul de c
(ligne 5): Nous savons que c
=
b
1
a
11
A
21
+ c (void (4.6)). Nous commencons
donc par calculer
b
1
a
11
(1 division). Puis nous multiplions le r esultat par le vecteur A
21
, il faut
n 1 multiplications. Finalement nous ajoutons le r esultat ` a c (n 1 additions). Le nombre
dop eration total est donc
1 + (n 1) + (n 1) = 2(n 1) + 1
Calcul de y (ligne 6): Il faut r esoudre un syst` eme de n 1 equations ` a n 1 inconnues. Nous
utilisons de nouveau le pivot de Gau (cest ici que linduction est utilis ee dans la construction),
il faut donc C
n1
op erations.
Calcul de s (ligne 7): Nous multiplions le vecteur ligne A
12
par le vecteur colonne y, cest un
produit scalaire de vecteurs ` a n 1 entr ees, il faut donc n 1 multiplications et n 2 additions,
un total de 2n 3 op erations.
Calcul de x
1
(ligne 8): Il faut une soustraction et une division, donc 2 op erations.
Nous avons alors:
C
n
= C
n1
+ 2n
2
+n 1
= C
n1
+O(n
2
).
Nous pouvons en d eduire que C
n
= O(n
3
) (exercice).
Remarquons cependant quil est possible que lalgorithme ne puisse pas etre appliqu e de
facon r ecursive puisque la condition a
11
,= 0 nest pas forc ement v eri ee. Il se peut quun
changement de pivot doive etre r ealis e an dobtenir cette condition. On d emontre en alg` ebre
lin eaire que ceci est toujours r ealisable si la matrice A est non-singuli` ere. Il sagit de calculs
auxiliaires qui ne changent pas lordre du temps de calcul.
94
4.3 LES ALGORITHMES DIVISER-POUR-R
EGNER
Lid ee des algorithmes diviser-pour-r egner (algorithmes DPR, divide-and-conquer) est de d e-
composer le probl` eme en deux ou plusieurs sous-probl` emes ind ependants qui peuvent ensuite
etre r esolus s epar ement. Les solutions de ces sous-probl` emes sont ensuite assembl ees (cest le
pas de combinaison), de facon ` a obtenir une solution au probl` eme original.
La technique diviser-pour-r egner est tr` es utile. Nous avons d ej` a rencontr e quelques algo-
rithmes de ce type dans ce cours: Les algorithmes de Karatsuba et de Strassen sont des algo-
rithmes DPR. Nous etudierons le paradigme g en eral des algorithmes DPR avant de voir quelques
exemples.
4.3.1 Le paradigme DPR general
Le concept g en eral est le suivant: etant donn e une instance du probl` eme ` a r esoudre, la d ecomposer
en plusieurs plus petites sous-instances (du m eme type), les r esoudre ind ependamment, et ensuite
combiner les solutions des sous-instances pour obtenir une solution du probl` eme original.
Cette description nous am` ene ` a une question importante: comment r esoudre les sous-instan-
ces? La r eponse ` a cette question est primordiale pour les algorithmes DPR et explique en effet
leur puissance. La forme pr ecise dun algorithme DPR est donn ee par:
La taille limite n
0
de linput, qui donne la taille au dessous de laquelle un probl` eme nest plus
divis e.
La taille n/a de sous-instances r esultant de la d ecomposition dune instance.
Le nombre c de telles sous-instances.
Lalgorithme utilis e pour recombiner les solutions des sous-instances.
La forme g en erale dun algorithme DPR sur un input de taille n qui a une taille limite n
0
et
qui divise le probl` eme original en c sous-instances de taille n/a est la suivante:
Algorithme 21 DPR
Input: de taille n
1: if n n
0
then
2: R esoudre le probl` eme sans le sous-diviser
3: else
4: D ecomposer en c sous-instances, chacune de taille n/a;
5: Appliquer lalgorithme r ecursivement ` a chacune des sous-instances;
6: Combiner les c sous-solutions r esultantes pour obtenir la solution du probl` eme original.
7: end if
95
Analyse
Pour calculer le temps de parcours de cet algorithme g en erique, nous supposons que le co ut
de la ligne 6 est dn
b
(pour une certaine constante b et une certaine constante d). Soit T(n) le co ut
de lalgorithme sur un input de taille n. Alors pour n n
0
, nous avons
T(an) = cT(n) +dn
b
.
Nous supposons de plus que pour tout n N : T(n) T(n+1). Alors, par le Th eor` eme 2.1
du chapitre 2, nous avons
T(n) =
_
_
O
_
n
log
a
(c)
_
si a
b
< c,
O
_
n
log
a
(c)
log
a
(n)
_
si a
b
= c,
O
_
n
b
_
si a
b
> c.
(4.7)
Le temps de parcours dun algorithme DPR d epend donc de la taille et du nombre de sous-
instances, ainsi que du co ut n ecessaire pour les combiner.
4.3.2 Lalgorithme de Karatsuba
Pour des polyn omes f(x) et g(x) de degr e < n, lalgorithme de Karatsuba retourne le produit
f(x) g(x).
Algorithme 22 KARATSUBA(f(x), g(x))
1: if n = 1 then
2: return f
0
g
0
3: else
4: m n/2
5: f(x) = f
0
(x) +x
m
f
1
(x), g(x) = g
0
(x) +x
m
g
1
(x), deg(f
0
), deg(g
0
) < m
6: h
0
(x) Karatsuba(f
0
(x), g
0
(x))
7: h
2
(x) Karatsuba(f
0
(x) +f
1
(x), g
0
(x) +g
1
(x))
8: h
1
(x) Karatsuba(f
1
(x), g
1
(x))
9: h(x) = h
0
(x) +x
m
(h
2
(x) h
0
(x) h
1
(x)) +x
2m
h
1
(x)
10: return h(x)
11: end if
Analyse
Nous divisons notre probl` emes en sous-probl` emes plus petits jusqu` a ce que n 1 (ligne 1),
et donc n
0
= 1.
Le probl` eme est divis e en 3 sous-instances (lignes 6,7 et 8) donc c = 3.
La taille de chaque sous instance est ` a peu pr` es n/2, donc a = 2 (puisque les polyn omes
utilis es sont de degr e < m avec m = n/2).
96
Lalgorithme pour combiner les sous-instances est d ecrit ` a la ligne 9. Son co ut est O(n), et
donc b = 1.
Ainsi, comme a
b
= 2 < c = 3, le co ut de lalgorithme est
O(n
log
2
(3)
).
4.3.3 Recherche binaire
Lalgorithme de recherche binaire que nous avons vu dans le chapitre 0 est aussi un algorithme
DPR. Nous rappelons dabord la d enition du probl` eme de localisation:
Probl` eme: Probl` eme de localisation
Input: Une suite dentiers S
0
< S
1
< < S
n1
, deux indices start
et end, et x Z
Output: Un indice i avec start i < end, et tel que S[i] = x, ou FALSE
si un tel indice nexiste pas
Lid ee de la recherche binaire et de diviser la suite en deux parties ` a peu pr` es de m eme
taille en posant une unique question. Lalgorithme BINSEARCH peut etre d ecrit comme suit en
pseudo-code:
Algorithme 23 BINSEARCH(S, start, end, x)
1: Length end start;
2: if Length = 1 then
3: if S[start] = x then
4: return start
5: else
6: return FALSE
7: end if
8: else
9: middle (end + start)/2;
10: if x < S[middle] then
11: return SEARCH(S, start, middle, x);
12: else
13: return SEARCH(S, middle, end, x);
14: end if
15: end if
Analyse
97
Dans ce cas, le probl` eme est divis e en une seule sous-instance, et donc c = 1.
Le co ut de chaque sous-instance est ` a peu pr` es n/2, et donc a = 2.
Le co ut de combiner les sous-solutions est 0, donc b = 0.
Ainsi a
b
= 1 = c, et le co ut de lalgorithme est donc
O
_
n
log
a
(c)
log
a
(n)
_
= O(log(n)).
4.3.4 MergeSort
MERGESORT est un algorithme de tri qui utilise le fait que deux suites tri ees peuvent etre r eunies
(merged) en une seule suite ` a faible co ut. Cet algorithme divise les objets ` a trier en deux groupes,
puis trie chaque groupe et enn les r eunit en une suite nale et tri ee.
Nous commencons par etudier lalgorithme de r eunion.
Algorithme 24 MERGE(S
1
, S
2
)
Input: Suites tri ees S
1
et S
2
de tailles n et m
Output: Suite tri ee S de S
1
S
2
1: i 0, i
1
0, i
2
0
2: while i < n +m do
3: if i
2
= m then
4: S[i] = S
1
[i
1
]
5: i
1
i
1
+ 1
6: else if i
1
= n then
7: S[i] = S
2
[i
2
]
8: i
2
i
2
+ 1
9: else if S
1
[i
1
] < S
2
[i
2
] then
10: S[i] = S
1
[i
1
]
11: i
1
i
1
+ 1
12: else
13: S[i] = S
2
[i
2
]
14: i
2
i
2
+ 1
15: end if
16: i i + 1
17: end while
18: return S
Le nombre de comparaisons de cet algorithme est n+m qui est egal ` a la taille de linput. On
peut se servir de cet algorithme pour construire un algorithme de tri DPR.
Analyse
Le probl` eme est sous-divis e en 2 sous-instances (lignes 6 et 7), et donc c = 2.
Chaque sous-instance est de taille ` a peu pr` es egale n/2, donc a = 2.
98
Algorithme 25 MERGESORT(S)
Input: Suite S de n entiers
Output: Version tri ee S
de S
1: if n = 1 then
2: return S
3: else
4: m n/2
5: Soit S
1
la sous-suite de S compos ee des m premiers el ements de S, et S
2
la sous-suite
form ee des autres el ements.
6: S
1
MERGESORT(S
1
)
7: S
2
MERGESORT(S
2
)
8: return MERGE(S
1
, S
2
)
9: end if
Le co ut n ecessaire pour combiner les sous-solutions est le co ut de lop eration MERGE et est
donc egal ` a O(n), do` u b = 1.
Ainsi, a
b
= c, et le co ut de lalgorithme est donc
O
_
n
log
a
(c)
log
a
(n)
_
= O(nlog(n)).
4.3.5 La paire la plus proche
Supposons que nous voulons trouver la distance euclidienne minimale entre des points du plan
R
2
. Nous supposerons de plus que tous nos points ont des coordonn ees x et y diff erentes.
Formellement:
Probl` eme: La paire la plus proche
Input: Un ensemble de n points P
1
, . . . , P
n
dans le plan, avec P
i
=
(x
i
, y
i
) R
2
. Supposons de plus que i ,= j = x
i
,= x
j
et
y
i
,= y
j
.
Output: La distance euclidienne minimale entre deux points distincts de
cet ensemble.
Dans un premier temps, les coordonn ees x des points sont tri ees en ordre croissant. Ensuite,
une valeur x
0
est d etermin ee telle que n/2 des points ont une coordonn ee x plus petite que x
0
tandis que les autres points ont une coordonn ee x plus grande que x
0
. Les deux sous-ensembles
de points sont not es L
1
et L
2
; lalgorithme est appliqu e r ecursivement ` a ces sous-ensembles pour
obtenir les distances minimales
1
et
2
de ces ensembles.
99
Il ny a que trois possibilit es en ce qui concerne la paire la plus proche dans lensemble : elle
est soit dans L
1
, soit dans L
2
ou le long de la fronti` ere. Il ne nous reste donc qu` a v erier les
points le long de la fronti` ere.
Nous d eterminons lensemble S de points dont la coordonn ee x est ` a une distance au plus
:= min
1
,
2
de x
0
.

Nous trions les coordonn ees y de ces points et nous parcourons les points dans lordre croissant
de la coordonn ee y. Pour chaque point Q nous mesurons sa distance par rapport ` a tous les points
dans S dont la coordonn ee y est au plus plus grande que la coordonn ee y de Q (tous les autres
points ont une distance ` a Q qui est plus grande que ). Il peut y avoir au plus 5 tels points dans
S, en plus de Q, avec cette propri et e. Voici une conguration de ces points:
Ainsi, pour un point quelconque dans S nous devons calculer au plus 5 distances.
Apr` es avoir trait e tous les points de S de cette mani` ere, nous saurons si la distance minimale
le long de la fronti` ere est plus petite que , et si cest le cas, nous aurons d etermin e la distance
minimale. Les algorithmes de tri des valeurs le long les coordonn ees x et y peuvent etre effectu es
une fois au d ebut des calculs avec co ut O(nlog(n)) (voir le Chapitre 6 pour les algorithmes de
tri).
100
Le co ut n ecessaire pour combiner les sous-solutions (calculer la distance minimale le long
de la fronti` ere) est lin eaire en n. Ainsi, le co ut total de lalgorithme est O(nlog(n)).
4.3.6 Carrelage de formes L
Supposons que nous avons un carr e de taille 2
k
2
k
dans lequel nous enlevons un carr e de taille
1 1:
Le probl` eme est de carreler cette structure avec des pi` eces de taille 3 en forme de L:
Nous allons utiliser un algorithme DPR pour cette tache.
Si k = 1 (donc la structure originale est un carr e 2 2 avec un sous-carr e manquant), alors
la solution est triviale:
Etant donn e un carr e de taille 2

k
2
k
, nous le subdivisons en 4 carr es de taille 2
k1
2
k1
chacun et nous enlevons dans chaque sous-carr e qui ne contient pas la pi` ece 1 1 manquante la
pi` ece 1 1 du coin de facon ` a ce que les carr es enlev es forment une pi` ece de forme L.
Remarquons que chacun des sous-carr es a un carr e 1 1 manquant, et que donc lalgorithme
sapplique r ecursivement. Nous appliquons donc r ecursivement lalgorithme aux sous-carr es. Le
carrelage complet est montr e dans lexemple suivant:
101
4.4 PROGRAMMATION DYNAMIQUE
La m ethode DPR sapplique si un probl` eme peut etre subdivis e en sous-probl` emes ind ependants,
qui sont ensuite r esolus r ecursivement. La programmation dynamique (Dynamic Programming,
DP) peut etre appliqu ee si les sous-probl` emes ne sont pas ind ependants et ont eux-m emes des
sous-probl` emes communs. Chaque instance est r esolue une seule fois et les r esultats sont stock es
dans un tableau pour eviter la d etermination r ep et ee des solutions des sous-probl` emes.
Exemple: Supposons que nous voulons calculer le n
` eme
nombre de Fibonacci, donn e par la
formule de r ecurrence
F
0
= 0,
F
1
= 1,
F
n
= F
n1
+F
n2
, n 2.
Voici la m ethode DPR nave:
Algorithme 26 FIB(n)
Input: Entier n 0
Output: F
n
1: if n 1 then
2: return n
3: else
4: return FIB(n 1) + FIB(n 2);
5: end if
Cette m ethode est simple, el egante et correcte. Cependant elle a un temps de parcours ex-
ponentiel en n. En effet, soit C
n
le temps de parcours de FIB(n). Alors C
n
= C
n1
+ C
n2
et C
2
= 1, C
3
= 2. On peut alors d emontrer en partant de cette relation que C
n
= O(
n
), o` u
102
= (1 +
5)/2. En fait, on peut d emontrer par r ecurrence que

C
n
=
1
5
_
1 +
5
2
_
n
+
1
5
_
1
5
2
_
n
,
et comme 0 < (1
5)/2 < 1, le r esultat C

n
= O(
n
) sensuit.
Le temps de parcours exponentiel de lapproche DPR est essentiellement d u au fait que le
m eme sous-probl` eme est calcul e plusieurs fois. Par exemple, larbre suivant montre les appels
r ecursifs pour le calcul de FIB(4):
Fib(0)
Fib(4)
Fib(2) Fib(3)
Fib(2)
Fib(1)
Fib(0)
Fib(1)
Fib(1)
Nous voyons par exemple que FIB(2) est calcul e deux fois. Il serait plus efcace de stocker
sa valeur dans un tableau la premi` ere fois que nous en avons besoin, plut ot que de le recalculer ` a
chaque fois.
La technique principale en DP est dutiliser des tableaux qui stockent les solutions de sous-
probl` emes qui peuvent ensuite etre r eutilis ees. La programmation dynamique est une tech-
nique qui calcule efcacement des etapes de r ecurrence en triant les r esultats partiels. Ainsi,
en m emorisant les r esultats dune r ecurrence, lalgorithme ne passe pas de temps ` a r esoudre le
m eme sous-probl` eme plusieurs fois. Comme lillustre lexemple, cette technique aide parfois ` a
r eduire le temps de parcours dexponentiel ` a polynomial.
Typiquement (mais pas exclusivement), on utilise DP pour r esoudre des probl` emes qui ont
en g en eral plusieurs solutions qui peuvent etre compar ees ` a laide dune fonction de co ut: Nous
nous int eressons alors ` a une solution de co ut minimal.
103
4.4.1 Multiplication de plusieurs matrices
Probl` eme: Disposition de parenth` eses dans les multiplications de matri-
ces
Input: Une suite (A
1
, . . . , A
n
) de matrices de tailles p
0
p
1
, p
1

p
2
, . . . , p
n1
p
n
, respectivement.
Output: Les parenth` eses de lexpression A
1
A
n
qui minimisent le nom-
bre de multiplications scalaires si lalgorithme naf de multiplica-
tion de matrices est utilis e.
Remarquons que de mani` ere g en erale, la multiplication dune matrice pq avec une matrice
q r n ecessite pqr multiplications.
Exemple: Pour n = 4, il y a 5 dispositions possibles des parenth` eses:
(A
1
(A
2
(A
3
A
4
)))
(A
1
((A
2
A
3
) A
4
))
((A
1
A
2
) (A
3
A
4
))
((A
1
(A
2
A
3
)) A
4
)
(((A
1
A
2
) A
3
) A
4
)
Pour n quelconque le nombre de dispositions possibles est un peu plus compliqu e ` a trouver:
Th eor` eme 4.1 Pour le produit A
1
A
n
, le nombre de facons dont on peut placer les par-
enth` eses est exactement
1
n
_
2n 2
n 1
_
=
_
4
n
n
3/2
_
.
Preuve. Exercice.
Pour certaines tailles de matrices, les dispositions de parenth` eses peuvent avoir des diff erences
de co ut importantes.
Exemple: Soient A
1
, A
2
et A
3
des matrices de tailles suivantes:
A
1
: 10 100
A
2
: 100 5
A
3
: 5 50
104
Voici le nombre dop erations n ecessaires pour le calcul de A
1
A
2
A
3
selon la disposition des
parenth` eses:
Disposition Nombre de multiplications scalaires
(A
1
A
2
) A
3
10 100 5 + 10 5 50 = 7500
A
1
(A
2
A
3
) 10 100 50 + 100 5 50 = 75000
Ainsi nous pouvons calculer le produit 10 fois plus rapidement en choisissant la bonne disposi-
tion de parenth` eses.
Le th eor` eme 4.1 montre que le nombre de dispositions de parenth` eses est exponentiel en
n. Ce nest donc pas une bonne id ee de toutes les essayer pour trouver la plus efcace. Nous
r esoudrons ce probl` eme en utilisant DP. La solution sera etablie en quatre etapes:
1. Structure de la disposition optimale des parenth` eses
2. Calcul r ecursif de la valeur dune solution optimale
3. Calcul du co ut optimal
4. Construction dune solution optimale
Structure dune disposition optimale de parenth` eses
Pour 1 i j n, posons
A
i...j
:= A
i
A
i+1
A
j
.
Pour une disposition optimale de A
1...n
, il existe un k tel que A
1...k
et A
k+1...n
sont dabord
calcul es avec une disposition optimale de parenth` eses, et les r esultats sont ensuite multipli es. Ce
type doptimalit e (bottom-up optimality) est typique pour des solutions DP.
Calcul r ecursif de la valeur dune solution optimale
Soit m
ij
le nombre minimal de multiplications scalaires pour le calcul de A
i...j
. Nous avons
alors m
ii
= 0 pour 1 i n, et
m
ij
= min
ik<j
m
ik
+m
k+1,j
+p
i1
p
k
p
j
. (4.8)
Pour stocker les solutions optimales, nous introduisons aussi s
ij
qui est la valeur de k pour
laquelle le minimum de la formule ci-dessus est atteint:
m
ij
= m
is
ij
+m
s
ij
+1,j
+p
i1
p
s
ij
p
j
. (4.9)
105
Calcul du co ut optimal
Nous allons construire deux matrices M et S de telle facon que M[i, j] = m
ij
et S[i, j] =
s
ij
. Remarquons que seules les valeurs au dessus de la diagonale nous int eressent (celles pour
lesquelles i j). Les matrices M et S seront mises ` a jour en commencant par la diagonale, puis
les el ements au dessus de la diagonale et ainsi de suite. Pour n = 4 les entr ees de M seraient
donc calcul ees dans lordre suivant:
_
_
_
_
1 5 8 10
2 6 9
3 7
4
_
_
_
_
Pour calculer M[i, j] il faut comparer j i valeurs diff erentes (pour k = i, . . . , j 1 dans
(4.9)). Chacune de ces valeurs ` a comparer peut etre trouv ee avec un co ut constant, puisque
les el ements de M n ecessaires dans (4.9) auront d ej` a et e calcul es. Ainsi pour tous les i, j qui
nous int eressent (cest ` a dire i = 1, . . . , n et j = i, . . . , n), le co ut pour calculer M[i, j] est
proportionel ` a j i. Le co ut total de lalgorithme est donc proportionel ` a
n
i=1
n
j=i
(j i) =
n (n + 1) (2n 2)
12
= (n
3
). (4.10)
La preuve de (4.10) est laiss ee en exercice. Ce temps de parcours est donc bien meilleur que
celui de lalgorithme naf, qui est exponentiel. On obtient au nal:
Exemple: Supposons que nous voulons multiplier les matrices A
1
, . . . , A
6
, de tailles suivantes:
Matrice Taille Matrice Taille
A
1
30 35 A
4
5 10
A
2
35 15 A
5
10 20
A
3
15 5 A
6
20 25
Nous avons donc
p
0
= 30
p
1
= 35
p
2
= 15
p
3
= 5
p
4
= 10
p
5
= 20
p
6
= 25.
106
Algorithme 27 MATRIX-CHAIN-ORDER(p)
Input: p = (p
0
, p
1
, . . . , p
n
) d ecrivant les tailles des matrices
Output: Matrices M et S comme d ecrites ci-dessus
1: n length(p) 1
2: for i = 1 . . . n do
3: M[i, i] = 0
4: end for
5: for = 2 . . . n do
6: for i = 1 . . . n + 1 do
7: j i + 1
8: M[i, j] =
9: for k = i . . . j 1 do
10: q M[i, k] +M[k + 1, j] +p
i1
p
k
p
j
11: if q < M[i, j] then
12: M[i, j] q
13: S[i, j] k
14: end if
15: end for
16: end for
17: end for
18: return M et S
Les matrices M et S sont alors:
M =
_
_
_
_
_
_
_
_
0 15750 7875 9375 11875 15125
0 2625 4375 7125 10500
0 750 2500 5375
0 1000 3500
0 5000
0
_
_
_
_
_
_
_
_
S =
_
_
_
_
_
_
_
_
0 1 1 3 3 3
0 2 3 3 3
0 3 3 3
0 4 5
0 5
0
_
_
_
_
_
_
_
_
Par exemple, M[1, 3] et M[2, 5] on et e calcul es en utilisant (4.8) comme suit:
M[1, 3] = min
_
M[1, 2] +M[3, 3] +p
0
p
2
p
3
= 15750 + 0 + 30 15 5 = 18000
M[1, 1] +M[2, 3] +p
0
p
1
p
3
= 0 + 2625 + 30 35 5 = 7875
= 7875
M[2, 5] = min
_
_
_
M[2, 2] +M[3, 5] +p
1
p
2
p
5
= 0 + 2500 + 35 15 20 = 13000
M[2, 3] +M[4, 5] +p
1
p
3
p
5
= 2625 + 1000 + 35 5 20 = 7125
M[2, 4] +M[5, 5] +p
1
p
4
p
5
= 4375 + 0 + 35 10 20 = 11375
= 7125
107
Construction dune solution optimale
Nous utilisons la table S[i, j]. Remarquons que S[i, j] = k signie que A
i...j
est construit de
mani` ere optimale ` a partir de A
i...k
et A
k+1...j
.
Exemple: Pour les matrices A
1
, . . . , A
6
ci-dessus, nous obtenons
A
1...6
= ((A
1...3
) (A
4...6
)) [S[1, 6] = 3]
= ((A
1
(A
2
A
3
)) ((A
4
A
5
) A
6
))
[S[1, 3] = 1 et S[4, 6] = 5].
Ainsi
((A
1
(A
2
A
3
)) ((A
4
A
5
) A
6
))
est une disposition de parenth` eses de co ut minimal pour A
1
A
6
.
4.4.2 Le problème LCS
Le probl` eme de la plus longue sous-suite (LCS, Longest Common Subsequence) est un autre
exemple pour lequel la DP est bien adapt ee. Nous introduisons les notations suivantes: Si X =
x
1
, . . . , x
m
) est une suite de longueur m, alors une suite Z = z
1
, . . . , z
k
) est appel ee une sous-
suite de X sil existe des indices 1 i
1
< i
2
< < i
k
m tels que pour tout 1 j k nous
avons
z
j
= x
i
j
.
Exemple: La suite
X = A, B, C, B, D, A, B)
a
Z = B, C, D, B)
comme sous-suite. La suite des indices correspondante est (2, 3, 5, 7).
Une suite Z est appel ee une sous-suite commune de X et Y si Z est ` a la fois sous-suite de X
et de Y . Lensemble des sous-suites communes de X et Y est not e CS(X, Y ). La longueur de
la plus longue sous-suite de X et Y est not ee
lcs(X, Y ),
et lensemble des sous-suites les plus longues de X et Y est not e par
LCS(X, Y ).
Nous nous int eressons aux probl` emes suivants, pour lesquels nous donnerons des solutions
DP:
108
Calculer lcs(X, Y )
Construire un el ement de LCS(X, Y )
Nous commencons par donner quelques propri et es de LCS(X, Y ). Soit X = x
1
, . . . , x
m
)
une suite. Pour 1 j m, nous notons par X
j
le pr exe
X
j
:= x
1
, . . . , x
j
).
Th eor` eme 4.2 Soient X = x
1
, . . . , x
m
), Y = y
1
, . . . , y
n
) et soit Z = z
1
. . . , z
k
) LCS(X, Y ).
Alors:
(1) Si x
m
= y
n
, alors z
k
= x
m
= y
n
et Z
k1
LCS(X
m1
, Y
n1
).
(2) Si x
m
,= y
n
, alors z
k
,= x
m
implique Z LCS(X
m1
, Y ).
(3) Si x
m
,= y
n
, alors z
k
,= y
n
implique Z LCS(X, Y
n1
).
Preuve. (1) Si z
k
,= x
m
, alors nous pouvons acoller ` a Z x
m
= y
n
, ce qui donnerait une sous-
suite commune de X et Y de longueur k + 1, mais ceci contredit Z LCS(X, Y ). Donc,
z
k
= x
m
= y
n
et le pr exe Z
k1
est une sous-suite commune de X
m1
et Y
n1
.
Nous montrons ` a pr esent que Z
k1
LCS(X
m1
, Y
n1
). Supposons que W LCS(X
m1
, Y
n1
)
est de longueur k. Alors la juxtaposition
Wx
m
= Wy
n
est une sous-suite commune de X et Y de longueur k + 1, ce qui contredit lcs(X, Y ) = k.
Ainsi X
m1
et Y
n1
nont aucune sous-suite commune de longueur > k 1 et donc Z
k1

LCS(X
m1
, Y
n1
).
(2) Si z
k
,= x
m
, alors Z CS(X
m1
, Y ). Sil existait W LCS(X
m1
, Y ) de longueur
> k, alors W appartiendrait aussi ` a CS(X, Y ), ce qui contredirait lcs(X, Y ) = k.
(3) Sym etrique ` a (2).
Remarquons que dans le cas x
m
,= y
n
au moins lune des afrmations (2) ou (3) est vraie. Le
th eor` eme 4.2 permet un calcul r ecursif de lcs(X, Y ). Soit
c
ij
= lcs(X
i
, Y
j
). (4.11)
Alors le th eor` eme nous dit que
c
ij
=
_
_
_
0 si i = 0 ou j = 0,
c
i1,j1
+ 1 si x
i
= y
j
,
max(c
i,j1
, c
i1,j
) si x
i
,= y
j
.
(4.12)
109
Ainsi, comme nous lavons fait dans les algorithmes DP pr ec edants nous pouvons calculer
et stocker les entr ees de la matrice c
ij
ligne par ligne, en utilisant ` a chaque fois les valeurs d ej` a
stock ees. Donc nous pouvons calculer chaque c
ij
avec un co ut constant puisque nous connaitrons
toutes les entr ees de la matrice c n ecessaires dans (4.12). Puisquil y a m n valeurs de c
ij
` a
calculer, le co ut total de lalgorithme sera (m n), et puisque la valeur que nous cherchons est
lentr ee en bas ` a droite de la matrice:
lcs(X, Y ) = c
mn
,
nous aurons bien trouv e la longueur de la plus grande LCS.
Nous pouvons aussi adapter cet algorithme pour quil retourne, en plus de la valeur de
lcs(X, Y ), un el ement de LCS(X, Y ). Pour ce, il nous faut une deuxi` eme matrice b, qui va
indiquer comment a et e obtenu c
ij
` a partir de c
i1,j1
, c
i,j1
, c
i1,j
avec (4.12)
En effet, si x
i
= y
j
alors cet el ement commun sera inclu dans une LCS (nous mettrons alors
b
ij
=
). Sinon si c
i1,j
c
i,j1
alors tout el ement de LCS(X
i
, Y
j
) sera aussi un el ement
de LCS(X
i1
, Y
j
), nous regardons donc lentr ee b
i1,j
(dans ce cas nous mettons b
ij
=
). Fi-
nalement si c
i1,j
< c
i,j1
cest le sym etrique du cas pr ec edant, et nous mettons donc b
ij
=
.
A partir de cette matrice b nous pourrons construire une suite dans LCS(X, Y ) (voir lexemple
ci-dessous pour une matrice b, et comment lutiliser pour trouver un el emet de LCS(X, Y )).
La proc edure suivante, LCS-LENGTH, calcule, pour deux suites X = x
1
, x
2
. . . x
m
) et
Y = y
1
, . . . , y
n
) donn ees, la valeur de lcs(X, Y ) et la matrice b d ecrite ci-dessus.
Exemple: Pour X = A, B, C, B, D, A, B) et Y = B, D, C, A, B, A) nous obtenons le tableau
suivant (les matrices b et c sont superpos ees):
j 0 1 2 3 4 5 6
i y
j
B D C A B A
0 x
i
0 0 0 0 0 0 0

1 A 0 0 0 0 1 1 1

2 B 0 1 1 1 1 2 2

3 C 0 1 1 2 2 2 2

4 B 0 1 1 2 2 3 3

5 D 0 1 2 2 2 3 3

6 A 0 1 2 2 3 3 4

7 B 0 1 2 2 3 4 4
110
Algorithme 28 LCS-LENGTH(X, Y )
Input: Suites X et Y
Output: lcs(X, Y ), et une matrice b d ecrivant un moyen de contruire un el ement dans
LCS(X, Y ).
1: m length[X]
2: n length[Y ]
3: for i 1 . . . m do
4: c[i, 0] 0
5: end for
6: for j 0 . . . n do
7: c[0, j] 0
8: end for
9: for i 1 . . . m do
10: for j 1 . . . n do
11: if x
i
= y
j
then
12: c[i, j] c[i 1, j 1] + 1
13: b[i, j]
14: else
15: if c[i 1, j] c[i, j 1] then
16: c[i, j] c[i 1, j]
17: b[i, j]
18: else
19: c[i, j] c[i, j 1]
20: b[i, j]
21: end if
22: end if
23: end for
24: end for
25: return c
mn
and b
111
Comme c
mn
= 4 nous avons lcs(X, Y ) = 4. Les ` eches permettent de lire un LCS en
commencant ` a la position (m, n) et en suivant ensuite les ` eches. Pour chaque case
travers ee il faut inclure l el ement correspondant dans notre LCS.

Ici nous commencons ` a la position (7, 6), puis nous montons ` a (6, 6). Comme cette case
contient un
nous ajoutons A ` a notre suite (x

6
= y
6
= A). Puis nous allons ` a la case
(5, 5), puis (4, 5), et nous ajoutons B a notre suite etc... En notant bien que nous construisons
notre LCS de la droite vers la gauche (donc en commencant par la n) nous obtenons au nal
B, C, B, A) pour notre el ement de LCS(X, Y ).
Remarques:(1) En modiant un peu cet algorithme nous pouvons obtenir une description de
tous les el ements de LCS(X, Y ), avec le m eme temps de parcours.
(2) Lalgorithme pr esent e ici n ecessite (m n) en temps et espace. Nous verrons
plus tard quil est possible de construire un algorithme de complexit e O(m p) en temps et en
espace, o` u p = lcs(X, Y ).
4.4.3 Le plus-court-chemin-pour-toute-paire (Floyd-Warshall)
Soit G un graphe dont les ar etes sont etiquet ees avec des entiers non-n egatifs. La longueur dun
chemin dans le graphe est la somme des etiquettes des ar etes sur ce chemin. Le probl` eme est
de trouver pour toutes les paires de sommets du graphe la longueur du plus court chemin qui les
relie.
1
2
3
4
5
6
1
1
4
5
3
2
5
3
Par exemple dans la situation ci-dessus, le chemin 6 2 3 est de longueur 2 + 3 = 5.
Formellement, un graphe etiquet e est un graphe G = (V, E) (V est lensemble des sommets et E
celui des ar etes), muni dune application w: E R
0
qui associe ` a chaque ar ete un r eel, appel e
son etiquette.
112
La solution DP du probl` eme du plus-court-chemin-pour-toute-paire a et e d ecouverte par
Floyd et Warshall. Soit V = 1, ..., n. Alors lalgorithme se base sur lid ee suivante: Fixons
k n. Pour toute paire de points i et j, nous trouvons le plus court chemin entre i et j, mais qui
nutilise que les sommets 1, . . . , k. Nous commencons avec k = 1 et continuons en incr ementant
k jusqu` a n.
Soit c
k
ij
la longueur du plus court chemin entre i et j dont les sommets interm ediaires sont un
sous-ensemble de 1, . . . , k (et c
k
ij
= si un tel chemin nexiste pas). Nous posons aussi
c
0
ij
=
_
w(i, j) si (i, j) E,
sinon.
Pour k 1, nous avons (exercice: pourquoi?):
c
k
ij
= minc
k1
ij
, c
k1
i,k
+c
k1
k,j
. (4.13)
Dans le m eme esprit que pour les deux probl` emes pr ec edants, nous calculons et stockons
donc dabord toutes les entr ees c
0
ij
, puis toutes les entr ees c
1
ij
, que nous calculons en utilisant
(4.13) et les valeurs c
0
ij
d ej` a stock ees. Nous continuons ainsi en calculant c
k
ij
jusqu` a k = n, en
utilisant ` a chaque fois (4.13) et les entr ees c
k1
ij
d ej` a calcul ees.
Le temps de parcours de cet algorithme est clairement O(n
3
), et il utilise un espace O(n
2
).
Exemple: Utilisons le graphe pr ec edent. Quand k = 0 nous pour c avons la matrice suivante:
_
_
_
_
_
_
_
_
1
3 5
3
1
4
5 2
_
_
_
_
_
_
_
_
.
Pour k = 1 nous avons
_
_
_
_
_
_
_
_
1
3 5
3
1
4
5 2 6
_
_
_
_
_
_
_
_
.
k = 2:
_
_
_
_
_
_
_
_
1
3 5
3
1 4 6
4
5 2 5 6 7
_
_
_
_
_
_
_
_
.
113
Algorithme 29 APSP(G)
Input: G = (V, E), un graphe etiquet e avec V = 1, . . . , n et etiquette w: E R
0
Output: Matrice (c
ij
)
1in
, o` u c
ij
est la longueur du chemin le plus court entre i et j.
1: for i = 1 . . . n do
2: for j = 1 . . . n do
3: if (i, j) E then
4: c[i, j] w(i, j)
5: else
6: c[i, j]
7: end if
8: end for
9: end for
10: for k = 1 . . . n do
11: for i = 1 . . . n do
12: for j = 1 . . . n do
13: d = c
ik
+c
kj
14: if d < c
ij
then
15: c
ij
= d
16: end if
17: end for
18: end for
19: end for
20: return c
114
k = 3:
_
_
_
_
_
_
_
_
1
3 5 6
3
1 4 6 7
4
5 2 5 6 7 8
_
_
_
_
_
_
_
_
.
k = 4:
_
_
_
_
_
_
_
_
2 5 1 7 8
3 5 6
3
1 4 6 7
5 8 4 10 11
5 2 5 6 7 8
_
_
_
_
_
_
_
_
.
k = 5:
_
_
_
_
_
_
_
_
2 5 1 7 8
10 3 9 5 6
3
1 4 10 6 7
5 8 4 10 11
5 2 5 6 7 8
_
_
_
_
_
_
_
_
.
k = 6:
_
_
_
_
_
_
_
_
13 2 5 1 7 8
11 8 3 9 5 6
8 5 8 9 10 3
12 1 4 10 6 7
16 5 8 4 10 11
5 2 5 6 7 8
_
_
_
_
_
_
_
_
.
Cette derni` ere matrice montre les chemins les plus courts entre toutes les paires de sommets. Par
exemple la longueur du chemin le plus court entre le sommet 5 et le sommet 6 est 11.
4.4.4 Le Problème 0/1-Knapsack (Sac-à-dos 0/1)
Supposons que nous avons n objets avec:
des poids w
1
, . . . , w
n
N,
des valeurs v
1
, . . . , v
n
,
et un poids maximal W N.
115
La t ache est de trouver un sous-ensemble S 1, . . . , n pour lequel la somme
iS
v
i
est maximale, et tel que
iS
w
i
W.
Comment pouvons nous trouver la valeur optimale?
Lalgorithme naf regarderait tous les sous-ensembles de 1, . . . , n et aurait donc un temps
de parcours exponentiel (rappelons que le nombre de sous-ensembles possibles est 2
n
). Nous
pouvons utiliser ici un algorithme DP, car le probl` eme a la propri et e structurelle suivante:
Si nous retirons lobjet j de lensemble optimal, alors lensemble r esultant doit etre optimal
pour le poids maximal W w
j
.
En effet, dans le cas contraire, la solution originale ne serait pas optimale.
Soit c
iw
la valeur de la solution optimale en nutilisant que les objets 1, . . . , i, et si le poids
maximal est w. Nous avons alors
c
iw
=
_
_
_
0 si i = 0 ou w = 0,
c
i1,w
si w
i
> w,
maxv
i
+c
i1,ww
i
, c
i1,w
si i > 0 et w w
i
.
(4.14)
Comme pour les trois probl` emes pr ec edants, nous allons calculer et stocker les entr ees c
iw
ligne par ligne. A chaque fois la valeur de c
iw
sera calcul ee en utilisant (4.14) et les entr ees de c
d ej` a stock ees. Nous obtenons donc lalgorithme suivant:
116
Algorithme 30 KNAPSACK(w, v, W)
Input: w = (w
1
, . . . , w
n
), v = (v
1
, . . . , v
n
), W N
Output: Valeur V telle que V = max
iS
v
i
pour tout S 1, . . . , n avec
iS
w
i
W.
1: for w = 0 . . . W do
2: c
0,w
0
3: end for
4: for i = 1 . . . n do
5: c
i,0
0
6: for w = 1 . . . W do
7: if w
i
w then
8: if v
i
+c
i1,ww
i
> c
i1,w
then
9: c
iw
= v
i
+c
i1,ww
i
10: else
11: c
iw
= c
i1,w
12: end if
13: else
14: c
iw
= c
i1,w
15: end if
16: end for
17: end for
18: return c
nW
.
Le temps de parcours de cet algorithme est clairement O(nW) (boucles aux lignes 4 et 6). Il
est donc bien meilleur que lalgorithme naf qui est exponentiel en n.
Exemple: Supposons que notre poids maximal est W = 20, et que nous avons 5 objets avec les
poids et valeurs suivants:
Objet 1 2 3 4 5
Valeur 19 11 10 12 21
Poids 3 6 5 4 12
Le parcours de lalgorithme peut etre d ecrit par le graphique ci-dessous:
117
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19
0 0 0 19 19 19 19 19 19 30 30 30 30 30 30 30 30 30 30 30 30
0 0 0 19 19 19 19 19 29 40 40 40 40 40 40 40 30 30 30 30 30
0 0 0 19 19 19 19 31 31 31 31 31 41 42 42 42 42 42 52 52 52
0 0 0 19 19 19 19 31 31 31 31 31 41 42 42 42 42 42 52 52 52
Ligne 0 de C
Ligne 1 de C
Ligne 2 de C
Ligne 3 de C
Ligne 4 de C
Ligne 5 de C
Valeur 19, Poids 3
Valeur 11, Poids 6
Valeur 10, Poids 5
Valeur 12, Poids 4
Valeur 21, Poids 12
La valeur maximale est donc 52. Il y a deux ensembles dobjets qui atteignent ce maximum:
(19, 3), (11, 6), (10, 5), (12, 4) et (19, 3), (12, 4), (21, 12)
118
4.5 UN ALGORITHME PLUS RAPIDE POUR LE PROBL
`
EME
LCS
Soient X et Y deux suites de longueur n et m respectivement, avec n m. Nous constru-
irons dans cette section un algorithme qui trouve un el ement de LCS(X, Y ) en temps et espace
O(mp), o` u m est la longueur de Y et p = lcs(X, Y ). Rappelons que lalgorithme pour le
probl` eme LCS vu dans la section 4.4.2 avait un temps de parcours O(mn).
Nous commencons par etudier lensemble M = (i, j) [ X
i
= Y
j
de tous les el ements qui
se correspondent dans X et Y .
Exemple: Si X = B, D, C, A, B, A) et Y = A, B, C, B, D, A, B) (Comme pour lexemple
de dans la section 4.4.2), lensemble M peut etre repr esent e par les points dans le diagramme
suivant:
A
B
C
B
D
A
B
3
C
4
A
5
B
6
A i
1
2
3
4
5
6
7
j 1
B
2
D
(suite X)
(suite Y)
Consid erons la relation sur (N N) d enie comme suit:
(k, l) (k
, l
) k < k
l < l
.
Cette relation d enit un ordre partiel sur lensemble M. (Rappelons quun ordre partiel est une
relation transitive et asym etrique.)
Remarque: Comme nest pas un ordre total, il se peut que M ait des el ements non-comparables.
Par exemple, pour (4, 1), (3, 3) M nous navons ni (4, 1) (3, 3), ni (3, 3) (4, 1).
Un sous-ensemble C M ne contenant que des el ements comparables sappelle une chane.
Une antichane A M est un sous-ensemble dans lequel il ny a pas deux el ements qui sont
comparables.
Exemple. Quelques chanes:
119
A
B
C
B
D
A
B
3
C
4
A
5
B
6
A i
1
2
3
4
5
6
7
j 1
B
2
D
3
1
2
Il est clair quune chane correspond ` a un el ement dans CS(X, Y ). Ici nous avons
1 = B, D)
2 = B, C, A, B)
3 = A, B, A)
Exemple. Quelques antichanes:
A
B
C
B
D
A
B
3
C
4
A
5
B
6
A i
1
2
3
4
5
6
7
j 1
B
2
D
2
3
1
Notre but est donc de trouver une chane de longueur maximale. Nous regardons dabord
un lien int eressant entre chanes et antichanes. Pour expliquer ce lien, nous avons besoin de
la notion de d ecomposition dun ensemble ni et partiellement ordonn e. Cest un ensemble
dantichanes A
1
, A
2
, . . . , A
k
tel que chaque el ement de M est contenu dans au moins une des
A
i
:
M = A
1
A
k
.
Une d ecomposition minimale est une d ecomposition contenant aussi peu dantichanes que pos-
sible.
120
Th eor` eme 4.3 Dans un ensemble ni et partiellement ordonn e M, la longueur p dune chane
maximale est egale ` a la taille dune d ecomposition minimale de M.
Preuve. Soit A
1
, . . . , A
k
une d ecomposition minimale de M, et soit C une chane maximale
avec p el ements. Si k < p, alors il existe c, c
C, c ,= c
, tels que c et c
sont dans la m eme

antichane (par le principe des tiroirs). Cest impossible, et donc k p.
Pour montrer que k p, nous construisons une d ecomposition en p antichanes. Ainsi sil
existe une d ecomposition en p antichanes, alors une d ecomposition minimale aura certainement
au plus p antichanes. Pour c M, soit (c) la longueur dune chane maximale avec plus grand
el ement c. Si (c) = (c
), alors c et c
sont incomparables (Pourquoi?). Donc

A
i
:= c [ (c) = i, 1 i p
forment p antichanes qui couvrent M.
La construction de la preuve dans notre cas est comme suit:
A
B
C
B
D
A
B
3
C
4
A
5
B
6
A
1
A
A
4
A
3
A
2
i
1
2
3
4
5
6
7
j 1
B
2
D
Le lemme suivant sugg` ere quil est facile de calculer une chane maximale ` a partir de cette
d ecomposition.
Lemme 1 Soit A
1
, . . . , A
p
la d ecomposition minimale de M telle que
A
i
:= c [ (c) = i, 1 i p,
comme d ecrite ci-dessus. Soit 2 i p. Alors nous avons
c
i
A
i
c
i1
A
i1
tel que c
i1
c
i
.
121
Preuve. Si c
i
A
i
, alors (c
i
) = i, et il existe une chane
m
1
m
2
m
i1
c
i
.
Comme m
1
m
2
m
i1
nous avons (m
i1
) i 1. Mais (m
i1
) i nest pas
possible, puisque ceci impliquerait (c
i
) i + 1. Donc, (m
i1
) = i 1, i.e., m
i1
A
i1
. On
choisit donc c
i1
:= m
i1
.
Pour obtenir une chane de longueur maximale, nous commencons avec un el ement c
p
A
p
quelconque, puis nous choisissons c
p1
A
p1
avec c
p1
c
p
; ensuite nous choisissons c
p2

A
p2
avec c
p2
c
p1
, etc. Ceci nous fournit une chane compl` ete de longueur p:
c
1
c
2
c
p1
c
p
,
et par cons equent un el ement de LCS(X, Y ).
Il ne reste donc plus qu` a trouver une d ecomposition minimale A
1
, . . . , A
p
de notre ensem-
ble M. Nous Pour ce, Nous construisons nos antichanes de haut en bas. Nous parcourons M
ligne par ligne, en ajoutant le point (i, j) ` a lantichane A
k
si et seulement sil ne se trouve pas ` a
droite du point le plus ` a gauche de A
k
. Nous appelons s
k
la colonne du point le plus ` a gauche de
A
k
.
Pour lexemple ci-dessus nous obtenons:
Ligne 1: Nous ajoutons (1, 4) et (1, 6) ` a A
1
, et nous avons donc s
1
= 4. Pour linstant nous
navons quune seule antichane non vide:
3
C
4
A
5
B
6
A i
1
j 1
B
2
D
A
.
.
.
Ligne 2: Le premier point sur la ligne 2 est (1, 2). Il est dans la premiere colonne et 1 s
1
nous
lajoutons donc ` a A
1
. Le prochain point est (2, 5), cette fois comme 5 > s
1
nous ne lajoutons
pas ` a A
1
. Par contre lantichane A
2
est vide nous ajoutons donc (2, 5) ` a A
2
. Ainsi maintenant
s
1
= 1 et s
2
= 5. Nous avons donc deux antichanes non vides:
3
C
4
A
5
B
6
A i
1
2
j 1
B
2
D
A
B
.
.
.
122
Ligne 3: Le seul point sur la ligne 3 est (3, 3). Comme 3 > s
1
nous ne lajoutons pas ` a A
1
. Par
contre 3 s
2
, nous ajoutons donc (3, 3) ` a A
3
. Ainsi maintenant s
1
= 1 et s
2
= 3. Nous avons
toujours deux antichanes non vides:
3
C
4
A
5
B
6
A i
1
2
3
j 1
B
2
D
A
B
C
.
.
.
Ligne 4: Nous ajoutons (4, 1) ` a A
1
et (4, 5) ` a A
3
. Donc maintenant s
1
= 1, s
2
= 3 et s
3
= 5.
Nous avons 3 antichanes non vides: A
1
= (1, 6), (1, 4), (2, 1), (4, 1), A
2
= (2, 5), (3, 3) et
A
3
= (4, 5):
3
C
4
A
5
B
6
A i
1
2
3
4
j 1
B
2
D
A
B
C
B
.
.
.
etc.
Cette proc edure est r ealis ee par lalgorithme suivant:
Dans cet algorithme nous avons
i repr esente la ligne actuelle de M etudi ee.
A[k] repr esente lantichane A
k
.
s[k] repr esente la colonne actuelle la plus ` a gauche de lantichane A
k
.
Remarquons que s[j] = n + 1 si et seulement si A
j
est vide. A la n de lalgorithme, le
nombre dantichaines non vides est egal ` a
p = maxk [ s[k] n,
et les antichanes construites sont stock ees dans A[k], 1 k p.
123
Algorithme 31 FASTLCS(X, Y )
Input: Suites X et Y , de longueurs n et m.
Output: La d ecomposition minimale (A
1
, . . . , A
p
) de M, telle que A
i
= c [ (c) = i, o` u (c)
est la longueur dune chane maximale avec plus grand el ement c.
1: Construire lensemble M = (i, j) [ X
i
= Y
j
2: for k = 1 . . . n do
3: s[k] n + 1
4: A[k]
5: end for
6: for i = 1 . . . m do
7: l mink [ (i, k) M
8: k 1
9: while l n do
10: if l s[k] then
11: A[k] A[k] (i, j) M [ l j s[k]
12: temp s[k]
13: s[k] l
14: l minj [ (i, j) M j > temp
15: end if
16: k k + 1
17: end while
18: end for
19: p maxk [ s[k] n.
20: return (A[1], . . . , A[p]).
124
Th eor` eme 4.4 Lalgorithme ci-dessus a un temps de parcours de O(mp), o` u p = lcs(X, Y ).
Preuve. Exercice.
Remarque: Une fois que nous avons trouv e cette d ecomposition minimale (A
1
, . . . , A
p
) de M
nous utilisons le Lemme 1 pour en d eduire une chane de longueur maximale. Nous la constru-
isons de la droite vers la gauche.
Dans lexemple ci-dessus nous commencons par prendre un el ement de A
p
= A
4
, disons (6, 6).
Puis le Lemme nous dit quil existe un el ement (i, j) A
3
avec (i, j) (6, 6), prenons par
exemple (4, 5). Ensuite il nous faut un el ement de A
2
, (prenons (3, 3)) et nalement un el ement
de A
2
(prenons (2, 1)).
Puisque nous lavons construite en commencant ` a droite, notre chaine est
_
(2, 1), (3, 3), (4, 5), (6, 6)
_
,
et donc la sous-suite commune correspondante est
B, C, B, A).
125
5
Algorithmes gloutons
Pour r esoudre certains probl` emes doptimisation, il suft de faire un choix localement optimal ` a
chaque pas de lalgorithme. En effet, dans certain cas, une famille de choix localement optimaux
m` ene ` a une solution globalement optimale. Ce fait est au cur des algorithmes gloutons: un
algorithme glouton fait toujours le choix qui lui semble le meilleur sur le moment. Apr` es l etude
dun exemple typique, nous etudierons les aspects principaux de strat egies glouton. Ces strat e-
gies seront illustr ees ` a laide des exemples du probl` eme de sac ` a dos et du code de Huffman,
utilis e dans la compression des donn ees.
5.1 EXEMPLE: HORAIRES DE SALLES DE COURS
Cet exemple concerne le probl` eme de lordonnancement de plusieurs activit es qui rivalisent pour
lutilisation exclusive dune ressource commune, lobjectif etant de s electionner un ensemble de
taille maximale dactivit es mutuellement compatibles.
Probl` eme: n professeurs veulent utiliser la m eme salle de cours. Chaque professeur a une
pr ef erence pour un intervalle de temps: Le professeur i veut utiliser la salle dans lintervalle
[s
i
, f
i
).
La t ache de lorganisateur est de trouver un plus grand sous-ensemble (c.` a.d. un ensemble de
taille maximale) A de S = 1, . . . , n tel que pour i, j A, i ,= j, on a
[s
i
, f
i
) [s
j
, f
j
) = . (5.1)
La strat egie gloutonne est la suivante:
Nous trions dabord les intervalles selon leur temps darr et f
i
, an davoir
f
1
f
2
f
n
.
On peut faire ce tri en temps O(nlog(n)). Puis lalgorithme op` ere de la mani` ere suivante:
Th eor` eme 5.1 Lalgorithme GREEDYSELECTOR satisfait le nombre maximal de pr ef erences.
126
Algorithme 32 GREEDYSELECTOR(s, f)
Call: GREEDYSELECTOR(s, f)
Input: s et f sont des tableaux de longueur n, f
1
f
n
.
Output: Sous-ensemble A de 1, . . . , n v eriant (5.1).
1: n length[s]
2: A 1
3: j 1
4: for i = 2, . . . , n do
5: if s
i
f
j
then
6: A A i
7: j i
8: end if
9: end for
10: return A
Nous donnons maintenant une preuve de ce th eor` eme.
Preuve. Soit S = 1, 2, . . . , n lensemble des indices des pr ef erences. La pr ef erence 1, r ealis ee
par lalgorithme, a le temps darr et le plus t ot f
1
. Nous montrons quil y a une solution optimale
avec le premier choix fait par lalgorithme, que nous appelons choix glouton 1.
Soit A S une solution optimale. Supposons que k A a le temps darret minimal dans
cette solution, i.e., k v erie f
k
f
j
j A. Si k = 1, nous avons ni. Si k > 1, nous pouvons
remplacer A par A
= (A k) 1, comme f
1
f
k
par hypoth` ese. Ainsi, il y a une solution
optimale avec le choix glouton 1 que nous noterons de nouveau avec A.
Apr` es ce choix, nous appliquons la m eme strat egie aux pr ef erences restantes.
S
:= i S [ s
i
f
1
.
Alors, A 1 est une solution optimale pour S
: si la solution optimale B
pour S
est plus
grande que A 1, alors B
1 serait une solution pour S avec plus d el ements que A, ce qui

contredit lhypoth` ese que A est de taille maximale.
En appliquant une induction, on prouve le th eor` eme.
5.2

EL
EMENTS DUNE STRAT
EGIE GLOUTONNE
Un algorithme glouton est un algorithme qui maximise son prot ` a chaque etape. Ce nest
pas toujours la bonne m ethode pour r esoudre un probl` eme doptimisation. Exemple: les ux
de trafc! Si chaque conducteur optimise son propre prot ` a chaque point, alors la solution
convergente sera typiquement la pire pour tout le monde.
127
Comment peut-on d ecider si un probl` eme doptimisation peut etre r esolu de mani` ere optimale
en utilisant une strat egie gloutonne? Il ny a pas de recette g en eral pour ce faire. N eanmoins, un
algorithme glouton se propose si les propri et es suivantes sont v eri ees:
Strat egie Gloutonne: loptimumglobal peut etre atteint par une suite doptima locaux. Ceci
doit etre prouv e dans chaque cas inviduel.
Sous-structure optimale: un probl` eme doptimisation poss` ede une sous-structure optimale
si une solution optimale est compos ee de solutions optimales de sous-probl` emes.
Cette deuxi` eme propri et e est exploit ee par la programmation dynamique ainsi que la m ethode
gloutonne. Dans lexemple de la section pr ec edente nous avons vu que pour une solution opti-
male A du probl` eme de la salle de cours, si 1 A, alors A
= A 1 est une solution optimale

pour les pr ef erences dans S
= i S [ s
i
f
i
.
5.3 GLOUTON COMPAR
E
`
A LA PROGRAMMATION DYNA-
MIQUE: LE PROBL
`
EME DU SAC
`
A DOS
Le probl` eme du sac ` a dos 0/1 a et e pr esent e au chapitre pr ec edent. Nous consid erons une version
affaiblie de ce probl` eme: le probl` eme du sac ` a dos rationnel. Supposons que nous ayons
n objets de poids w
1
, w
2
, . . . , w
n
de valeurs v
1
, v
2
, . . . , v
n
,
et un poids maximal W N.
La t ache est de trouver x
i
Q, 0 x
i
1, tel que
n
i=1
x
i
w
i
W et la somme
n
i=1
x
i
v
i
soit maximale. La diff erence entre le probl` eme du sac ` a dos 0/1 et celui du sac ` a dos rationnel
est donc que ce dernier permet dajouter des morceaux dobjets dans le sac ` a dos, tandis dans le
sac ` a dos 0/1, on choisit chaque objet soit en complet, soit pas du tout.
Le probl` eme du sac ` a dos rationnel peut etre r esolu ` a laide dun algorithme glouton:
Pour chaque i nous calculons la valeur relative v
i
/w
i
.
Trier (en un temps O(nlog(n))) les objets selon leurs valeures relatives. Apr` es re-indexation
nous aurons alors
v
1
w
1
v
2
w
2

v
n
w
n
.
128
Trouver lincide m avec
m1
i=1
w
i
W <
m
i=1
w
i
.
On inclut alors les objets 1, . . . , m1 compl` etement, et de lobjet m la fraction
m
:=
W
m1
i=1
w
i
w
m
,
Les autres objets sont laiss es en dehors du sac ` a dos. En dautres termes, x
1
= =
x
m1
= 1, x
m
=
m
, et x
m+1
= = x
n
= 0.
Exercice: Prouver que ce choix des x
i
est optimal!
La m eme proc edure ne donne pas n ecessairement une solution optimale du probl` eme de sac
` a dos 0/1. Par exemple, consid erons linstance suivante:
i 1 2 3
w
i
10 20 30
v
i
60 100 120
v
i
/w
i
6 5 4
W = 50.
La solution optimale de cet exemple est donn e par le choix des objet 2 et 3 pour une valeur
totale de 220 et un poids de 50. Une solution incluant lobjet 1, dont la valeur relative est
maximal, ne peut pas etre optimale.
Pourquoi cela? Cest parce que dans le probl` eme du sac ` a dos 0/1, une solution optimale dun
sous-probl` eme ne s etend pas n ecessairement ` a une solution optimale du probl` eme plus grand.
La programmation dynamique prend en compte toutes les solutions des sous-probl` emes, et non
pas seulement les meilleures. Donc, la programmation dynamique fonctionne dans ce cas, alors
que la strat egie glouton echoue.
5.4 CODES DE HUFFMAN
Le codage de Huffman est une technique basique pour la compression sans perte (lossless com-
pression). Par la suite on parlera de code de longueur xe si tous les mots du code ont la m eme
longueur. Si ce nest pas le cas, on dira que le code est de longueur variable.
Exemple: Consid erons un chier w contenant 100000 lettres de lalphabet a, b, c, d, e, f. (I.e.,
w est un mot, appartenant ` a lensemble a, b, c, d, e, f
100000
.) Le mot w doit etre stock e en
repr esentation binaire.
129
Si nous utilisons un code de longueur xe, alors nous devrions repr esenter chacune des six
lettres avec trois bits. Par exemple:
a = 000 c = 010 e = 100
b = 001 d = 011 f = 101.
Ceci r esultera en 300000 bits pour une repr esentation binaire de ce chier.
Un code de longueur variable est en g en eral bien meilleur quun code de longueur xe, parce
quil est possible dassigner des suites binaires plus courtes aux lettres qui apparaissent plus
souvent. Pour lutiliser, la fr equence des lettres doit etre connue. (La fr equence dune lettre est
sa probabilit e dapparition. Par exemple, si 25% de toutes les lettres du mot sont des A, alors la
fr equence de A est 0.25.)
Exemple:
Lettre a b c d e f
Fr equence 0.45 0.13 0.12 0.16 0.09 0.05
Repr esentation (code) 0 101 100 111 1101 1100
Ce code a seulement besoin de 224000 bits (45000 1 + 13000 3 + 12000 3 + 16000 3 +
9000 4 +5000 4) et est 25% plus efcace que le code de longueur xe comme d ecrit ci-dessus.
Par la suite, nous verrons une technique (la m ethode de Huffman) qui permettra de trouver
le code de longueur variable le plus efcace pour un alphabet avec fr equences des lettres donn e.
Mais dabord, il faut pr eciser la terminologie. Soit C un alphabet ni.
Un code binaire pour C est une application injective
E: C 0, 1
+
.
Comme d ej` a annonc e, si tous les mots binaires dans limage de E ont la m eme longueur, alors
on dit que le code est un code de longueur xe, sinon cest un code de longueur variable.
Dans cette section, on ecrira c
1
c
2
c
n
le mot de longueur n et de lettres c
i
C. Aussi, si a
et b sont deux mots quelconques, nous notons le mot obtenu en juxtaposant a et b par ab, ` a moins
quil y ait une ambiguit e.
Un codage via E est lapplication (aussi not ee par E) suivante:
E : C
+
0, 1
+
c
1
c
n
E(c
1
) E(c
n
).
Autrement dit, le codage du mot c
1
c
n
se fait en codant chaque lettre c
i
individuellement et en
juxtaposant les mots obtenus.
Si E est injective sur C
+
, alors on dit que E est uniquement d ecodable. Dans ce cas, chaque
mot de code E(c
1
) E(c
n
) poss` ede une unique pr eimage et lapplication
D: E(c
1
) E(c
n
) c
1
c
n
130
sappelle un d ecodage pour E.
Un code sans pr exes (prex-code) est un code pour lequel aucun c Image(E) est le pr exe
dun autre el ement dans Image(E). Nous mentionnons le th eor` eme suivant sans preuve.
Th eor` eme 5.2 La compression optimale de donn ees sans perte est toujours possible en utilisant
un code sans pr exes.
Il est possible de repr esenter des codes binaires par des arbres binaires. Lexemple suivant
illustre comment ceci se fait, et le paragraphe suivant donnera ensuite une description pr ecise du
lien entre arbre et code.
Exemple: Code de longueur xe:
1
0.86 0.14
0.14 0.58 0.28
a : 0.45 b : 0.13 c : 0.12 d : 0.16 e : 0.09 f : 0.05
0 0
0
0 0
0
1 1 1
1
1
Larbre ci-dessus repr esente le code de longueur xe pour lalphabet a, b, c, d, e, f vu avant.
Le codage de la lettre a se lit sur les ar etes du chemin racine-a.
Nous avons vu que cet arbre nest pas optimal: le chier w etait plus long que n ecessaire.
Larbre du code de longueur variable de lexemple pr ec edent est repr esent e par larbre suivant:
131
1
0.55
0.14
0.25 0.30
a : 0.45
b : 0.13 c : 0.12 d : 0.16
e : 0.09
f : 0.05
0
0
0 0
0
1
1 1
1
1
Nous verrons que ce code est optimal, dans un sens ` a pr eciser.
Mais que veut dire optimal, et comment prouve-t-on quun arbre (ou un code) donn e est
optimal?
Comment trouve-t-on des arbres optimaux, pour alphabet et fr equences donn es?
5.4.1 Codes representes par des arbres binaires
Un arbre binaire etiquet e est un arbre binaire racin e muni dun etiquetage de ses ar etes par 0 et 1
tel que les etiquettes le long des ar etes des descendants sont diff erentes pour chaque sommet.
Soit C un alphabet ni donn e avec les fr equences f(c), c C. Les fr equences sont des nom-
bres r eels entre 0 et 1 dont la somme vaut 1. (Donc, f() d enit une distribution de probabilit es
sur C.)
Un arbre de compression pour C est un arbre binaire etiquet e dont les feuilles sont en cor-
respondance biunivoque avec les el ements de lalphabet et dont les sommets ont des poids. Le
poids dune feuille est la fr equence de l el ement associ e dans lalphabet. Le poids dun sommet
interne est la somme des poids de tous ses descendants directs.
Le code associ e ` a un arbre de compression est lensemble de toutes les suites binaires obtenu
en juxtaposant les etiquettes des ar etes pour chaque chemin de la racine ` a une feuille.
Th eor` eme 5.3 Le code associ e ` a un arbre de compression est un code sans pr exes.
132
Soit d
B
(c) la profondeur de l el ement c de lalphabet dans larbre de compression B. Alors
d
B
(c) est la longueur du mot de code associ e ` a c. La longueur moyenne dun mot de code est
alors
A(B) :=
cC
f(c)d
B
(c)
si lon choisit les lettres ` a encoder selon la loi f(c), i.e. une lettre c x ee est choisie avec proba-
bilit e f(c). La longueur moyenne A(B) est aussi appel ee le co ut de larbre de compression.
Un arbre de compression est optimal si son co ut est minimal pour lalphabet C et les fr equences
f(c), c C.
5.4.2 Le codage de Human
Le codage de Huffman est une m ethode de construction dun arbre de compression optimal pour
un alphabet avec des fr equences donn ees. Cette m ethode a et e invent ee par David Huffman en
1952 alors quil etait encore etudiant.
Cette m ethode construit larbre optimal de bas en haut (bottom-up), et cest un algorithme
glouton. Nous introduirons dabord cette construction. Ensuite nous prouverons loptimalit e de
la construction. Puis nous discuterons des structures de donn ees adapt ees ` a une impl ementation
de cet algorithme.
La technique de base:
1. Commencer avec autant darbres quil y a d el ements dans lalphabet: Associer aux arbres
(avec une seule feuille) l el ement correspondant de lalphabet et sa fr equence.
2. Tant quil y a plus dun arbre:
i. Trouver deux arbres de fr equence minimale.
ii. Combiner les arbres en un, en utilisant lun des arbres comme sous-arbre gauche et
lautre comme sous-arbre droit. Etiquetter le sous-arbre gauche avec 0, et le sous-arbre
droit avec 1. Etiquetter la racine du nouvel arbre avec la somme des co uts des deux
sous-arbres.
5.4.3 Implementation de lalgorithme de codage de Human
Nous utiliserons une queue ` a priorit e Qpour cette t ache. Qcontiendra les el ements de lalphabet
ainsi que leurs fr equences, (c, f(c)). Les el ements sont ordonn es par fr equence, de la plus petite
` a la plus grande.
La queue aura une fonction deletemin qui efface l el ement avec la plus petite fr equence.
La meilleure facon dimpl ementer cette structure de donn ees est dutiliser un binary heap. Nous
133
Algorithme 33 HUFFMAN(C, f)
Input: Un ensemble de caract` eres C de taille n = [C[. (Q est une queue ` a priorit e ordonn ee par
fr equence, initialement vide.)
Output: Arbre de compression Huffman T pour linput.
1: for c C do
2: Enqueue ((c, f(c)), Q).
3: end for
4: for i = 1, . . . , n 1 do
5: Cr eer un nouveau sommet z
6: left child = deletemin(Q)
7: right child = deletemin(Q)
8: f(z) = f(left child) +f(right child)
9: Les ls de z deviennent left child et right child
10: Enqueue ((z, f(z)), Q).
11: end for
verrons cette structure dans le chapitre suivant, dans lequel nous etudierons des algorithmes de
tri.
Le co ut de cet algorithme est egal au co ut des 2(n 1) deletemins et des n enqueue.
Si Q est implement ee par un binary heap, ces op erations co utent O(log(n)), le co ut total de
lalgorithme sera alors egal ` a O(nlog(n)).
Nous verrons des binary heaps dans le chapitre suivant, dans lequel nous etudierons des al-
gorithmes de tri.
Exemple: Voici comment lalgorithme op` ere sur lexemple pr esent e en d ebut de section:
1. Mise en place de Q:
d:0.16 a:0.45 f:0.05 e:0.09 c:0.12 b:0.13
134
2. i = 1 avec f(z) = 0.14:
1 0
d:0.16 a:0.45
e:0.09 f:0.05
0.14
b:0.13 c:0.12
3. i = 2 avec f(z) = 0.25:
0
1
0 1
0.14
f:0.05 e:0.09
d:0.16
0.25
c:0.12 b:0.13
a:0.45
4. i = 3 avec f(z) = 0.30:
0
0
1
0 1
a:0.45
1
0.25
c:0.12 b:0.13
0.30
0.14
f:0.05 e:0.09
d:0.16
135
5. i = 4 avec f(z) = 0.55:
0
0
c:0.12
1
1
1
d:0.16
0
1
0
f:0.05 e:0.09
0.14 b:0.13
0.30
0.55
0.25
a:0.45
6. i = 5 avec f(z) = 1:
0 1
0 1
0
1
c:0.12
0 1
d:0.16 0.14
0
1
e:0.09 f:0.05
b:0.13
0.25
0.55
a:0.45
1
0.30
136
5.4.4 Optimalite de lalgorithme de codage de Human
Nous voulons montrer que larbre de compression Huffman obtenu avec une paire (C, f) o` u C
est un alphabet ni et f est une distribution de probabilit e a un co ut optimal.
Soit x l el ement de C qui a la plus petite fr equence et y l el ement de C qui a la seconde plus
petite fr equence. Nous montrons dans un premier temps quil existe un arbre de compression
optimal dans lequel x et y ont le m eme parent.
Soit T un arbre de compression optimal. Notons que T peut etre transform e en un arbre op-
timal T
1
dans lequel x a une profondeur maximale : si x na pas d ej` a une profondeur maximale
dans T, il existe un el ement a dans T qui a une profondeur maximale et d(a) > d(x). Par hy-
poth` ese f(x) f(a). En interchangeant x et a dans T, on obtient un autre arbre de compression
T
1
. On a
A(T) A(T
1
) = (f(a) f(x))(d(a) d(x)
. .
>0
) 0.
On constate que f(a) = f(x) et que A(T) = A(T
1
). Ensuite, nous montrons que x a un fr` ere z
dans T
1
. Dans le cas contraire, x peut etre mont e et a une profondeur plus petite, et donc r eduit
le co ut de T
1
, ce qui contredit loptimalit e de T
1
. Notons que par hypoth` ese sur y, nous avons
f(z) f(y). En interchangeant z et y, on obtient un autre arbre de compression T
2
. Nous avons
A(T
1
) A(T
2
) = (f(z) f(y))(d(z) d(y)) 0.
Comme d(z) d(y) (Notons que d(z) est la profondeur maximale dans T
1
), nous voyons que
A(T
1
) = A(T
2
). Finalement, on a construit un arbre de compression optimal dans lequel x et y
ont le m eme parent.
T
x
y
a z
T
1
x
y
a
z
T
2
x y
a
z
Pour montrer que larbre de Huffman est un arbre de compression optimal pour (C, f), nous
proc edons par induction sur n, le nombre de caract` eres dans C. Si [C[ = 2, il ny a rien ` a
montrer.
137
Supposons maintenant que [C[ > 2. Soit le nouvel alphabet C = C x, y z, qui
contient [C[ 1 el ements et o` u f(z) = f(x) +f(y). Par hypoth` ese dinduction, lalgorithme de
Huffman construit un arbre de compression optimal T pour C. Supposons que le co ut de larbre
de Huffman sur C nest pas optimal, et soit T
1
un arbre de compression optimal pour C dans
lequel x et y ont le m eme parent (un tel arbre existe par la preuve ci-dessus). Comme x et y ont
le m eme p` ere dans T, on a
A(T) = A(T) d(z)(f(x) +f(y)) + (d(z) + 1)(f(x) +f(y))
= A(T) +f(x) +f(y).
De la m eme mani` ere, A(T
1
) = A(T
1
) +f(x) +f(y), o` u T
1
est obtenu de T
1
en enlevant x et y
et en donnant ` a lanc etre commun de x et y la valeur f(x) +f(y). Comme, par induction, A(T)
est optimal, on a
A(T) = A(T) +f(x) +f(y)
A(T
1
) +f(x) +f(y)
= A(T
1
).
Par optimalit e de T
1
, on voit que A(T) = A(T
1
), et donc T est un arbre de compression optimal.
138
6
Algorithmes de tri
On estime que plus de 25% du temps de calcul utilis e commercialement est pass e pour faire des
tris (sorting). Le d eveloppement de m ethodes de tri puissantes est donc tr` es utile et important.
Quest-ce que trier, et que signie etre efcace dans ce contexte? Le probl` eme du tri
peut etre enonc e de mani` ere pr ecise comme suit:
Probl` eme: Tri
Input: Des objets s
0
, . . . , s
N1
, dont chacun est muni dune cl e k
i
appar-
tenant ` a un ensemble totalement ordonn e (par exemple (Z, )).
Output: Permutation de 0, . . . , N 1 telle que k
(0)
k
(1)

k
(N1)
.
Nous d evelopperons des algorithmes de tri qui nutilisent que des comparaisons entre les
cl es. Nos algorithmes modieront linput an dobtenir un output pour lequel les cl es seront
tri ees dans lordre croissant.
De mani` ere g en erale, on distingue les algorithmes de tri internes et externes:
Les algorithmes de tri internes supposent que lacc` es al eatoire ` a chaque el ement est pos-
sible avec le m eme co ut. Cest le cas si les donn ees sont toutes stock ees dans la m emoire
vive.
Les algorithmes de tri externes supposent que objets sont stock es sur des m edia ext erieurs
et quils ne peuvent pas etre acc ed es avec le m eme temps.
Dans ce chapitre, nous regarderons uniquement des algorithmes de tri internes.
Nous supposons que les cl es sont des nombres entiers, et que les objets sont stock es dans un
tableau (array). Nous pouvons repr esenter les objets eux-m emes (que nous appelons aussi des
el ements) avec la structure
139
typedef struct {
int key;
Payload P;
} element;
et nos objets sont stock es dans un tableau
element a[N];
6.1 ALGORITHMES

EL
EMENTAIRES
Dans cette section nous etudierons quatre algorithmes de tri :
Selection Sort
Insertion Sort
Shell Sort
Bubble Sort
Quand nous mesurons les temps de parcours de ces algorithmes nous regardons deux pro-
pri et es:
Le nombre de comparaisons de cl es C
Le nombre de mouvements M (d eplacements)
Dans les deux cas nous nous int eressons au meilleur des cas, au pire des cas et au comporte-
ment moyen. Typiquement, il faut aux m ethodes d ecrites dans cette section O(N
2
) comparaisons
de cl es pour trier N objets dans le pire des cas.
Remarque: Techniquement, un mouvement consiste ` a copier un el ement dun endroit vers un
autre (par exemple dune position dans le tableau a vers une position en m emoire). Cependant, la
plupart des algorithmes dans ce chapitre font exclusivement des echanges d el ements ( echanger
l el ement ` a la position a[i] avec celui ` a la position a[j]).
Formellement, pour faire un echange il faut 3 mouvements (on copie le contenu de a[i] vers une
position temporaire t en m emoire, on copie le contenu de a[j] vers a[i], et on copie nalement t
vers a[j]).
Cependant, nous compterons un echange comme un seul mouvement. En effet nous nous int eressons
surtout au comportement asymptotique des algorithmes (donc avec la notation O), et celui-ci
reste le m eme si le nombre de mouvements est multipli e par une constante.
140
Soient C
min
(N), C
max
(N) et C
avg
(N) le nombre de comparaisons quutilise un algorithme
dans le meilleur cas, le pire des cas, et le cas moyen, respectivement. Par cas moyen, on entend
le comportement de lalgorithme en moyenne, en supposant que chaque permutation possible de
linput a la m eme probabilit e. C
avg
(N) est donc lesp erance du nombre de comparaisons.
De m eme, nous notons par M
min
(N), M
max
(N), et M
avg
(N) le nombre de mouvements
effectu es par un algorithme dans le meilleur cas, le pire des cas, et le cas moyen. (Nous rappelons
quun echange de deux el ements est consid er e comme un seul mouvement.)
Remarques:
(1) Quand nous parlons du temps de parcours dun algorithme de tri nous voulons en
g en eral dire la somme du nombre de mouvements et du nombre de comparaisons dont il a
besoin.
(2) Soit a[0], . . . , a[N 1] le tableau contenant nos objets. Nous abuserons parfois de la
notation en disant par exemple que l el ement a[i] est plus petit que l el ement a[j] (alors que
formellement il faudrait dire que la cl e de l el ement a[i] est plus petite que la cl e l el ement
a[j]).
(3) Soit a[0], . . . , a[N 1] le tableau contenant nos objets. Quand nous parlons du premier
el ement du tableau (ou de la suite) nous voulons dire a[0], quand nous parlons du deuxi` eme
el ement nous voulons dire a[1]. Donc de la m eme mani` ere quand nous parlons du i
` eme
el ement de la suite nous voulons dire a[i 1].
Dans tout le chapitre nous posons les hypoth` eses suivantes:
Les cl es sont les nombres 1, . . . , N.
Quand nous condid erons le comportement moyen de nos algorithmes, nous supposons que
les N! permutations possibles des cl es ont toutes la m eme probabilit e.
6.1.1 Selection Sort
Lid ee de cet algorithme est de trier une suite en d eterminant son plus petit el ement, puis son
deuxi` eme plus petit el ement, puis son troisi` eme plus petit, etc.
Plus pr ecis ement: Trouver la position j
0
du plus petit el ement dans la suite puis echanger a[0]
et a[j
0
]. Ensuite, d eterminer la position j
1
du plus petit l el ement parmi a[1], . . . , a[N 1], et
echanger a[1] et a[j
1
]. Nous continuons de cette mani` ere jusqu` a ce que tous les el ements soient
` a la bonne position.
141
Algorithme 34 SELECTIONSORT(a)
Input: Suite a d el ements avec des cl es enti` eres.
Output: Transformation de a telle que a[i].key a[i + 1].key pour 0 i < N 1
1: for i = 0, . . . , N 2 do
2: min i
3: for j = i + 1, . . . , N 1 do
4: if a[j].key < a[min].key then
5: min j
6: end if
7: end for
8: if min ,= i then
9: Echanger a[min] et a[i]
10: end if
11: end for
Analyse
Nombre de comparaisons: Pour trouver le plus petit el ement parmi possibilit es, il faut tou-
jours faire 1 comparaisons. Donc:
C
max
(N) = C
min
(N) = C
avg
(N) =
N2
i=0
(N 1 i) =
N(N 1)
2
= O(N
2
).
Nombre de mouvements: Nous rappelons dabord que les N! permutations possibles des cl es
ont toutes la m eme probabilit e. Donc chacun des nombres k, 1 k N apparat ` a une position
donn ee i avec probabilit e 1/N .
On obtient:
M
max
(N) = N 1.
M
min
(N) = 0 (la ligne 9 de lalgorithme neffectue l echange
que sil est n ecessaire).
M
avg
(N) =
N1
N
+
N2
N1
+ +
1
2
= N ln(N) (1) (exercice).
Exemple:
142
Position
15 2 43 17 4 7 47
15 43 17 4 7 47
43 17 15 7 47
2 4 7 15
4 2
4 2
2 4 7 15 17 43
17
17 43 47
47 43 17
43 47
7 15
15 7
47
0 1 3 4 5 6
2 4
2
2
Est-il possible de rendre lalgorithme plus efcace en choisissant une meilleure m ethode pour
le calcul du minimum ` a chaque etape?
Th eor` eme 6.1 Nimporte quel algorithme pour le calcul du minimum de i cl es utilise au moins
i 1 comparaisons (si seulement des comparaisons de cl es sont admises).
Preuve (esquisse). On dessine le graphe qui a pour chacune des i entr ees un sommet, et qui a une
ar ete entre chaque paire de sommets qui sont compar es. Par la formule dEuler pour les arbres
(c.f. section 1.3.1), si on effectue moins que i 1 comparaisons, ce graphe nest pas connexe.
Mais alors une composante peut etre strictement plus grande que lautre ou aussi strictement plus
petite, sans inuence sur les r esultats des comparaisons.
Mais le minimum se trouvera alors forc ement dans des composantes diff erentes dans ces deux
cas. Il sen suit que dans un de ces cas au moins, loutput de lalgorithme sera faux.
6.1.2 Insertion Sort
Algorithme de base
Lid ee est dins erer les el ements un par un dans une suite tri ee. En ins erant a[i], il faut sassurer
que la suite a[0], . . . , a[i 1] est d ej` a tri ee et ins erer a[i] ` a la bonne position.
Cet algorithme peut etre vu comme la m ethode utilis ee par un joueur de cartes qui place avec
la main droite les cartes distribu ees, une ` a une, dans sa main gauche, en placant au bon endroit
chaque carte dans les cartes d ej` a tri ees quil tient dans la main gauche.
Exemple
143
Algorithme 35 INSERTIONSORT(a)
Input: Suite a dobjets avec des cl es enti` eres.
1: for i = 1, . . . , N 1 do
2: j i 1
3: t a[i]
4: while a[j].key > t.key and j 0 do
5: a[j + 1] a[j]
6: j j 1
7: end while
8: a[j + 1] t
9: end for
2
15
2 15
2 4 15 17 43
43 17 15 7 4 2
2 4 7 15 17 43 47
17 43
2 15
15
43
47
47 7
7 4
4 7 47
47
17
17 43
43 2 4 17 7
4 7 47
47
Position 0 1 2 3 4 5 6
Analyse
Nombre de comparaisons: Pour trouver ` a quelle position ajouter le i
` eme
el ement a[i 1] dans
a[0], . . . , a[i 2], nous avons au moins 1 et au plus i 1 comparaisons ` a faire. On a donc
C
max
(N) =
N
i=2
(i 1) = O(N
2
)
C
min
(N) = N 1.
Il est aussi possible de montrer que
C
avg
(N) = O(N
2
).
Nombre de mouvements: Pour ins erer le i
` eme
el ement a[i 1] dans a[0], . . . , a[i 2] nous avons
144
au moins 2 et au plus 2 + (i 1) mouvements ` a effectuer (pourquoi?). Donc
M
max
(N) = 2(N 1) +
N
i=2
(i 1) = O(N
2
)
M
min
(N) = 2(N 1),
et il est aussi possible de montrer que
M
avg
(N) = O(N
2
).
Binary Insertion Sort
Dans la version de base de INSERTIONSORT, lalgorithme fait une recherche lin eaire pour trou-
ver dans a[0], . . . , a[i1] la position ` a laquelle a[i] doit etre ins er e. Cependant puisque a[0], . . . , a[i
1] est tri ee, nous pouvons aussi utiliser lalgorithme de recherche binaire (ce qui r eduit le nombre
de comparaisons n ecessaires, mais pas le nombre de mouvements).
Dans ce qui suit, nous supposons que la proc edure BINSEARCH(b, x) retourne, etant donn e
une suite tri ee b de longueur N, la position j ` a laquelle il faudrait ins erer x pour que b reste tri ee.
Plus formellement, loutput j doit v erier lune des 3 propri et es suivantes:
j ,= 0, N et b[j 1].key < x.key b[j].key.
j = 0 et x.key b[0].key.
j = N et b[N 1] < x.key.
Par ins erer x ` a la position j, nous entendons copier a[i] vers a[i + 1] pour tout i = N
1, . . . , j, puis copier x vers a[j + 1].
Algorithme 36 INSERTIONSORTBIN(a)
1: Poser a
(0)
:= (a[0])
2: for i = 1, . . . , N 1 do
3: Poser j BINSEARCH(a
(i1)
, a[i])
4: Ins erer a[i] dans a
(i1)
` a la position j, et appeler la suite r esultante a
(i)
5: end for
Analyse
Nombre de comparaisons: Nous supposons que toutes les cl es dans la suite sont distinctes. Pour
ins erer a[i] dans la suite a
(i1)
, il nous faut faire une recherche binaire. Le nombre minimum de
145
comparaisons pour ins erer a[i] est donc log
2
(i). Le nombre maximum de comparaisons est
log
2
(i). Donc
C
min
(N) =
N1
i=1
log
2
(i)
log
2
((N 1)!)
= O(N log(N)).
Pour des N arbitrairement grands, il existe des suites qui atteignent cette borne. De la m eme
facon, poue le nombre maximal de comparaison on a
C
max
(N) = O(N log(N)).
Le nombre moyen de comparaisons de lalgorithme de recherche binaire est O(log(N)).
Ainsi:
C
avg
(N) = O(N log(N)).
Nombre de mouvements: Le nombre de mouvements ne change pas avec BINSEARCH. Les
calculs restent donc les m emes que pour la version de base de INSERTIONSORT.
6.1.3 Shell Sort
Cet algorithme de tri a et e d evelopp e en 1959 par D.L. Shell. La d enition suivante est la base
de SHELLSORT.
D enition. Soit 0 < N. On dit quune suite de cl es k
0
, . . . , k
N1
est -tri ee si pour tout
0 i < N on a k
i
k
i+
.
En particulier, une suite tri ee est donc la m eme chose quune suite 1-tri ee.
Lid ee est de choisir une suite dincr ements h
t
> h
t1
> > h
1
= 1, et dutiliser INSER-
TIONSORT pour transformer la suite originale en une suite h
t
-tri ee S
t
, puis dutiliser de nouveau
INSERTIONSORT pour tranformer S
t
en une suite h
t1
-tri ee S
t1
, etc, pour nalement obtenir
une suite h
1
-tri ee (donc tri ee) S
1
. Un bon choix dincr ements diminue le nombre de mouvements
n ecessaires par rapport ` a INSERTIONSORT.
Exemple
146
2 15 43 4 7 47
3
2
1
osition P
h
h
h
47 7 4 17 43 2 15
7 2 43 17 4 15 47
47 43 4 17 15 2 7
17
=5
=3
=1
0 1 2 3 4 5 6
Quand h
3
= 5, on consid` ere les sous-suites suivantes obtenues par incr ement de 5:
15 7
InsertionSort
. . . 7 15
2 47
InsertionSort
. . . 2 47
43
17
4
Puis on remplace dans leur position originale les sous-suites tri ees:
7 2 43 17 4 15 47
Puis h
3
= 3 et on consid` ere les sous-suites suivantes obtenues par incr ement de 3:
7 17 47
InsertionSort
. . . 7 17 47
2 4
InsertionSort
. . . 2 4
43 15
InsertionSort
. . . 15 43
A nouveau, on remplace dans leur position originale les sous-suites tri ees:
7 2 15 17 4 43 47
Le cas h
1
= 1 revient ` a trier, avec INSERTIONSORT, la suite enti` ere.
Dans cet exemple, le nombre de mouvements est 6, par opposition aux 8 mouvements n ecessaires
si lon utilise le tri par insertion.
Analyse
La partie la plus importante est de trouver le meilleur choix des incr ements pour que le
nombre de mouvements aussi petit que possible. Une r eponse compl` ete ` a cette question nest
toujours pas connue. On peut cependant d emontrer les faits suivants:
147
Algorithme 37 SHELLSORT(a, h)
Input: Suite a d el ements avec des cl es enti` eres, suite dincr ements h
t
> h
t1
> > h
1
= 1.
1: for k = t, . . . , 1 do
2: h h
k
3: for i = h, . . . , N 1 do
4: v a[i]
5: j i
6: while j h and a[j h].key > v.key do
7: a[j] a[j h]
8: j j h
9: end while
10: a[j] v
11: end for
12: end for
Si une suite est k-tri ee et lalgorithme ci-dessus produit une suite h-tri ee pour h < k, alors
la nouvelle suite reste k-tri ee.
Si une suite de longueur N est 2-tri ee et 3-tri ee, alors on peut la trier avec un passage de
INSERTIONSORT en utilisant N comparaisons.
Pour tout n 1, si une suite de longueur N est 2n-tri ee et 3n-tri ee, alors la suite peut etre
n-tri ee en un passage de INSERTIONSORT en utilisant N comparaisons.
Soit 1 = h
1
< h
2
< h
3
< la suite contenant tous les entiers de la forme 2
a
3
b
pour
a, b 0. Le temps de parcours de lalgorithme SHELLSORT avec cette suite dincr ements
est O(N(log N)
2
) (nombre de comparaisons et de mouvements dans le pire des cas)
6.1.4 Bubble Sort
Lid ee de BUBBLESORT est tr` es simple: Lalgorithme proc` ede par etapes, o` u ` a chaque etape
nous parcourons la suite et comparons les el ements adjacents. Nous les echangeons sils ne
sont pas dans le bon ordre. Nous continuons ces etapes jusqu` a ce quil ny ait plus d echanges
n ecessaires.
Apr` es la premi` ere etape (aussi appel e premier passage), a[N1] est l el ement maximal de la
suite. Apr` es le deuxi` eme passage, a[N2] est l el ement maximal parmi a[0], . . . , a[N2] (donc
le 2
` eme
plus grand el ement de la suite). De m eme, apr` es la i
` eme
etape, a[N i] est l el ement
maximal parmi a[0], . . . , a[N i] (donc le i
` eme
plus grand el ement de la suite).
Donc apr` es l etape i, l el ement maximal parmi a[0], . . . , a[N i] a et e d eplac e jusqu` a la n
de cette suite (` a la position a[N i]); Comme une bulle qui monte ` a la surface de leau (et donc
le nom bubble sort).
148
Exemple
Position 0 1 2 3 4 5 6
1
er
pass. 15 2 43 17 4 7 47
2 15 43 17 4 7 47
2 15 17 43 4 7 47
2 15 17 4 43 7 47
2 15 17 4 7 43 47
2
` eme
pass. 2 15 17 4 7 43 47
2 15 4 17 7 43 47
2 15 4 7 17 43 47
3
` eme
pass. 2 15 4 7 17 43 47
2 4 15 7 17 43 47
2 4 7 15 17 43 47
R esultat 2 4 7 15 17 43 47
Algorithme 38 BUBBLESORT(a)
1: Continue TRUE
2: r N 1;
3: while Continue est TRUE do
4: Continue FALSE
5: for i = 0, . . . , r 1 do
6: if a[i].key > a[i + 1].key then
7: Swap a[i] and a[i + 1]
8: Continue TRUE;
9: end if
10: end for
11: r r 1
12: end while
Analyse
Meilleur cas: N 1 comparaisons et pas de mouvements (si la suite est d ej` a tr ee).
C
min
(N) = N 1
M
min
(N) = 0.
149
Pire des cas: Quand la suite est tri ee de facon d ecroissante (pourquoi?).
C
max
(N) =
N(N 1)
2
= O(N
2
),
M
max
(N) =
N
i=1
(i 1) = O(N
2
).
Cas moyen: On peut montrer (plus difcilement) que
C
avg
(N) = M
avg
(N) = O(N
2
).
Nous terminons ici notre discussion des algorithmes de tri el ementaires. Nous etudions main-
tenant des algorithmes de tri plus sophistiqu es avec des temps de parcours bien meilleurs.
150
6.2 QUICKSORT
Lalgorithme QUICKSORT a et e invent e en 1962 par C.A.R. Hoare. Le nom quicksort est d u
au fait que cest lun des algorithmes de tri les plus rapides connus.
Dans des applications typiques de tri, les el ements associ es aux cl es peuvent etre tr` es grands.
Par exemple, il pourrait sagir dun site web form e de beaucoup dimages, de chiers de son et
de vid eo, etc. Donc, la quantit e de m emoire associ ee ` a un el ement est une ressource pr ecieuse
quil ne faut pas gaspiller. Nous appelons ce type de m emoire du m emoire el ement pour
pouvoir distinguer ce type de m emoire de celui quutilise un programme pour fonctionner. Nous
disons quun algorithme est in-place sil utilise seulement une quantit e de m emoire el ement
suppl ementaire O(1). QUICKSORT est un algorithme in-place et diviser-pour-r egner. Dans le
pire des cas son temps de parcours est O(N
2
) pour trier une suite de longueur N (donc pas
meilleur que les algorithmes de la section pr ec edante), mais son temps de parcours en moyenne
est
O(N log(N)).
Lid ee est de choisir un el ement arbitraire b appel e le pivot dans la suite a[0], . . . , a[N 1] et
de diviser la suite en deux sous-suites S
1
et S
2
avec les propri et es suivantes:
S
1
contient les el ements a[i] avec
a[i].key b.key,
S
2
contient les a[i] avec
a[i].key > b.key.
Lalgorithme QUICKSORT est ensuite appliqu e r ecursivement ` a ces deux sous suites.
Comment pouvons-nous construire une version in-place de cet algorithme?
Une sous-suite de la suite originale est sp eci ee de facon unique par deux indices (a[]
est l el ement le plus ` a gauche) et r (a[r 1] est l el ement le plus ` a droite). A chaque appel
r ecursif de QUICKSORT nous appelons la routine en sp eciant et r. L etape la plus importante
de limpl ementation de cet algorithme est la subdivision en sous-suites.
Ici: L el ement pivot est le dernier el ement de la suite, donc a[r 1].
Nous prenons deux pointeurs p et q; Au d ebut p pointe vers l el ement a[r 1] et q vers
l el ement a[]. p se d eplace vers la gauche jusqu` a ce quil trouve un el ement plus petit que
a[r 1] (le pivot); de la m eme facon, q se d eplace vers la droite jusqu` a ce quil trouve un
el ement plus grand que a[r 1] (le pivot). Les contenus de a[p] et a[q] sont echang es, et le
processus est r ep et e jusqu` a ce que p < q. Puis a[r 1] et a[q] sont echang es.
Exemple (de l etape de subdivision)
151
Position ... 4 5 6 7 8 9 ...
5 7 3 1 6 4
Pivot
i j
...
1. i j
1 7 3 5 6 4
2. i
j
1 7 3 5 6 4
3. i j
1 7 3 5 6 4
...
...
...
...
...
...
...
Donc ici = 4 et r = 10 (attention, la suite qui nous int eresse est a[], a[ + 1], . . . , a[r 1],
soit r el ements). Le pivot est a[r 1], donc dans notre exemple on a pivot = a[9] = 4. Au
d epart p pointe vers a[r 1] (donc ici a[9]), et q vers a[] (donc ici a[4]).
Nous comparons a[p] avec le pivot et voyons que pivot a[p] (4 4), donc nous continuons
avec p.
Nous d eplacons p vers la gauche (donc maintenant p = 8) et comparons a[p] avec le pivot.
Puisque pivot a[p] (4 6) nous continuons avec p.
Nous d eplacons p vers la gauche (donc maintenant p = 7) et comparons a[p] avec le pivot.
Cette fois nous avons a[p] < pivot (1 < 4), nous laissons donc p en place et regardons q.
Nous comparons a[q] avec le pivot et voyons que pivot < a[q] (4 < 5) donc nous laissons q en
place.
Nous echangeons a pr esent a[q] et a[p]. Notre suite est donc maintentant 1, 7, 3, 5, 6, 4. Nous
recommencons.
Nous comparons a[p] (p = 7 toujours) avec le pivot et voyons que pivot a[p] (4 5), nous
continuons donc avec p.
Nous d eplacons p vers la gauche (donc maintenant p = 6). a[p] < pivot (3 < 4), nous laissons
donc p en place et regardons q.
Nous comparons a[q] (q = 4 toujours) avec le pivot et voyons que a[q] pivot (1 4) donc
nous continuons avec q.
Nous d eplacons q vers la droite (donc maintenant q = 5) et comparons a[q] avec le pivot. Cette
fois nous avons pivot < a[q] (4 < 7) nous laissons donc q en place.
Nous echangeons a pr esent a[q] et a[p]. Notre suite est donc maintentant 1, 3, 7, 5, 6, 4. Nous
recommencons.
Nous comparons a[p] (p = 6 toujours) avec le pivot et voyons que pivot a[p] (4 7), nous
continuons donc avec p.
152
Nous d eplacons p vers la gauche (donc maintenant p = 5) a[p] < pivot (3 < 4), nous laissons
donc p en place et regardons q.
Nous comparons a[q] (q = 5 toujours) avec le pivot et voyons que a[q] pivot (3 4) donc
nous continuons avec q.
Nous d eplacons q vers la droite (donc maintenant q = 6) et comparons a[q] avec le pivot. Cette
fois nous avons pivot < a[q] (4 < 7) nous laissons donc q en place.
Comme p < q (5 < 6) ne n echangeons pas a[p] et a[q], mais sortons de la boucle principale.
Nous echangeons a[q] et a[r 1] (donc a[6] et a[9]) pour obtenir comme suite 1, 3, 4, 5, 6, 7.
Les deux sous-suites sont donc 1, 3 (a[4], a[5]) et 5, 6, 7 (a[7], a[8], a[9]) avec le pivot 4 au milieu.
Nous appelons donc QUICKSORT(a, 3, 6) et QUICKSORT(a, 7, 10)
Algorithme 39 QUICKSORT(a, , r)
Input: Suite a d el ements avec des cl es enti` eres, indices et r
Output: Transformation de a[], . . . , a[r1] telle que a[i].key a[i+1].key pour i < r1
1: if r + 1 then
2: return
3: end if
4: q
5: p r 1
6: pivot a[r 1].key
7: while p > q do
8: while a[p].key pivot and p > l do
9: p p 1
10: end while
11: while a[q].key pivot and q < r 1 do
12: q q + 1
13: end while
14: if p > q then
15:

Echanger a[p] et a[q]
16: end if
17: end while
18: if q ,= r 1 then
19: Echanger a[q] et a[r 1]
20: end if
21: QUICKSORT(a, , q)
22: QUICKSORT(a, q + 1, r)
153
Exemple:
1 3 5 7
1 3 2 7 5 6
7 6 2 3 1 5 4
15 12
7 6 2 3 1 5 4 12 9 15 10
15
7 6 2 3 1 5 4 9
quicksort(a, 0, 11)
quicksort(a, 0, 8) quicksort(a, 9, 11)
quicksort(a, 0, 7)
quicksort(a, 0, 3) quicksort(a, 4, 7)
Analyse
On voit facilement que le temps de parcours est au plus O(N
2
). Pour une suite ordonn ee
de facon d ecroissante, le nombre de comparaisons et de d eplacements est (N
2
), si le pivot est
choisi comme pr ec edemment. Ainsi,
C
max
(N) = (N
2
),
M
max
(N) = (N
2
).
On voit facilement que le temps de parcours est (N), puisque chaque el ement de la suite
doit etre inspect e. Pour une suite ordonn ee de facon croissante, le nombre de mouvements est 0.
Le nombre de comparaisons doit satisfaire C
min
(N) = 2C
min
(N/2) + O(N). Donc en utilisant
le th eor` eme 2.1, on peut conclure que
C
min
(N) = O(N log(N))
M
min
(N) = 0.
154
Analysons maintenant le comportement moyen de QUICKSORT. Soit T
k
(N) le co ut total
(comparaisons + mouvements) moyen de QUICKSORT si le pivot est le k
` eme
el ement le plus
petit, et T
avg
(N) le co ut moyen de QUICKSORT pour trier une suite de longueur N. Alors
T
avg
(N) =
1
N
N
k=1
T
k
(N),
et
T
k
(N) = bN
..
sousdivision
+ T
avg
(k 1) +T
avg
(N k),
pour une constante b.
T
avg
(N) = bN +
1
N
N
k=1
(T
avg
(k 1) +T
avg
(N k))
= bN +
2
N
N
k=1
T
avg
(k).
De l` a, on peut montrer (par induction) que
T
avg
(N) cN log(N),
pour une constante c ind ependante de N.
6.2.1 Variantes
Le choix du pivot est crucial pour la performance de lalgorithme QUICKSORT. Il y a plusieures
strat egies pour choisir le pivot, les plus connues sont 3-median strategy (strat egie 3-m edianes)
et randomized strategy (strat egie al eatoire):
3-Median Strategy: On choisit comme pivot la m ediane de 3 el ements de la suite (par
exemple la m ediane du premier, dernier et el ement du milieu).
Randomized Strategy: On choisit comme pivot un el ement al eatoire dans la suite. Avec
cette strat egie, la probabilit e que QUICKSORT ait une mauvaise performance sur une suite
donn ee est tr` es petite.
6.3 HEAP SORT
Heapsort est une technique de tri qui avec un temps de parcours moyen comparable ` a celui de
QUICKSORT (O(N log(N))), mais qui a aussi un temps de parcours O(N log(N)) dans le pire
des cas.
155
Heapsort est aussi une methode in-place. Un array a de longueur N peut etre consid er e
comme un arbre binaire avec racine de la facon suivante (repr esentation implicite): Les sommets
de larbre correspondent aux positions 0, . . . , N 1. La racine est ` a la position 0, et les ls des
positions i sont aux positions 2i +1 et 2i + 2, ` a condition que ces valeurs soient plus petites que
N. Nous appelons un tel arbre un array-tree binaire.
Il est evident que la hauteur du array-tree binaire dun array de longueur N est O(log(N)).
(Pourquoi?)
Un tableau a satisfait la heap property (propri et e de monceau) si
a[i].key a[2i + 1].key pour tout i v eriant 2i + 1 < N
a[i].key a[2i + 2].key pour tout i v eriant 2i + 2 < N
On appelle un arbre binaire qui correspond ` a un tableau a un heap (monceau) si le tableau v erie
la propri et e heap.
Exemple: Le tableau [8,6,7,3,4,5,2,1] v erie la propri et e de heap, parce que
8 6, 8 7
6 3, 6 4; 7 5, 7 2
3 1.
a[0]
a[1]
a[2]
a[3] a[4] a[5] a[6]
a[7]
8
6 7
5 2 4 3
1
Comme d ej` a mentionn e, un heap contenant N sommets a une hauteur de O(log(N)).
6.3.1 Sifting
La proc edure de sift (le criblage en francais) est une proc edure efcace qui peut etre utilis ee pour
ins erer ou enlever des el ements dans un heap.
Nous apprendrons deux techniques de sifting: le sift up et le sift down. En utilisant la
terminologie des graphes, on peut d ecrire la proc edure de SIFTDOWN de l el ement dindice i
dans le tableau a de taille N comme suit:
156
Algorithme 40 SIFTDOWN(a, i)
Input: Suite a de N el ements ` a cl es enti` eres, et un entier i, 0 i < N pour lequel a[i +
1], . . . , a[N 1] v erie la propri et e de heap.
Output: Transformation de a telle que a[i], a[i + 1], . . . , a[N 1] v erie la propri et e de heap.
1: Swapped true
2: while Swapped = true and 2i + 1 < N do
3: Swapped false
4: Trouver le plus grand ls a[j] de a[i]
5: if a[j].key > a[i].key then
6: Echanger a[i] et a[j]
7: i j
8: Swapped true
9: end if
10: end while
Si le sommet i est une feuille ou sil est plus grand que ses ls on ne fait rien. Sinon
on echange le sommet i avec le plus grand de ses ls et on recommence ce proc ed e de facon
r ecursive sur le ls quon vient d echanger.
La performance de SIFTDOWN est facile ` a analyser:
Th eor` eme 6.2 SIFTDOWN utilise au plus O(log(N/i)) comparaisons et echanges.
Preuve. Remarquons dabord que le nombre de comparaisons est au plus deux fois la distance
entre le sommet i et le bas de larbre (deux comparaisons par niveau), et le nombre d echanges
est au plus egal ` a ce nombre. La diff erence entre la hauteur totale du heap et la hauteur du
sommet i est O(log(N) log(i)), et lafrmation sensuit.
La proc edure SIFTDOWN a un analogue appel e SIFTUP. La proc edure SIFTUP peut etre
appliqu ee au i-` eme sommet, si a[0], . . . , a[i1] v erient d ej` a la propri et e de heap; apr` es SIFTUP
on aura alors que a[0], . . . , a[i 1], a[i] v erient la propri et e de heap. Lid ee est d echanger a[i]
avec son parent si n ecessaire, et de continuer ensuite avec le parent.
Il est facile de montrer que le co ut de cette proc edure est O(log(i)) (Exercice.)
6.3.2 Creation dun heap
Comment transformer un tableau donn e en un heap? Nous verrons deux m ethodes pour cr eer un
heap: La m ethode top-down et la m ethode bottom-up.
La m ethode top-down consiste ` a traverser la suite a[0], . . . , a[N 1] de la gauche vers la
droite. Au pas i 1, nous effectuons un SIFTUP de l el ement a[i] dans le heap a[0], . . . , a[i 1]
d ej` a cr e e. Un argument dinduction montre que le r esultat nal est aussi un heap.
157
Algorithme 41 SIFTUP(a, i)
Input: Suite a de N el ements ` a cl es enti` eres, et un entier i, 0 i < N avec a[0], . . . , a[i 1]
v eriant la propri et e de heap.
Output: Transformation de a telle que a[0], . . . , a[i] verie la propri et e de heap.
1: Swapped true
2: while Swapped = true et i > 0 do
3: Swapped false
4: j (i 1)/2 (a[j] est alors le parent de a[i].)
5: if a[j].key < a[i].key then
6: Echanger a[j] et a[i]
7: i j
8: Swapped true
9: end if
10: end while
Algorithme 42 TOPDOWNHEAPCREATE(a)
Input: Suite a d el ements avec N cl es enti` eres.
Output: Transformation de a[0], . . . , a[N 1] en un heap.
1: for i = 1, . . . , N 1 do
2: SIFTUP(a, i)
3: end for
Le temps de parcours de cet algorithme peut etre facilement analys e. A l etape i, le co ut de
SIFTDOWN est O(log(i)), le co ut total de lalgorithme est donc
N
i=2
O(log(i)) = O(log(N!)) = O(N log(N)).
La deuxi` eme m ethode pour cr eer un heap sappelle bottom-up et consiste ` a cr eer plusieurs
petits heaps. Cette fois nous traversons a[0], . . . , a[N 1] de la droite vers la gauche. A chaque
etape i la condition heap est v eri ee pour les el ements a[i], a[i + 1], . . . , a[N 1]. L el ement
a[i 1] est ins er e dans le heap en le siftant dans larbre binaire original.
Exemple: Creation dun heap utilisant lapproche bottom-up. Dans cet exemple, les lettres en
gras indiquent la partie qui est d ej` a transform ee en heap. Valeurs sous-lign ees: Sift-down.
158
Tableau: 2 1 5 3 4 8 7 6
a[3].key = 3: 2 1 5 6 4 8 7 3
a[2].key = 5: 2 1 8 6 4 5 7 3
a[1].key = 1: 2 6 8 3 4 5 7 1
a[0].key = 2: 8 6 7 3 4 5 2 1.
Algorithme 43 BOTTOMUPHEAPCREATE(a)
Input: Suite a ` a N el ements, avec cl es entiers.
Output: Transformation de a[0], . . . , a[N 1] en un heap.
1: for i = (N 2)/2, . . . , 0 do
2: SIFTDOWN(a, i);
3: end for
Le temps de parcours de cet algorithme est bien meilleur que celui de lapproche top-down:
pour chaque sommet dans larbre original, le co ut de SIFTDOWN est (au plus) proportionnel ` a la
distance du sommet au dernier niveau de larbre.
Pour un arbre complet binaire ` a 2
h
1 sommet (et de hauteur h 1), on peut montrer par
induction que la somme des distances des sommet au dernier niveau est
2
h
(h + 1).
Il sensuit que le temps de parcours de lapproche bottom-up est O(N).
6.3.3 Lalgorithme HEAPSORT
Nous sommes maintenant pr ets ` a d enir lalgorithme de tri HEAPSORT. La d emarche est la
suivante:
Nous commencons avec la suite a[0], . . . , a[N 1].
Nous la transformons en un heap en utilisant lapproche bottom-up ou top-down.
Pour chaque s = 1, . . . , N 1, nous echangeons la racine de larbre (a[0]) avec a[N s], puis
faisons un SIFTDOWN de a[0] dans larbre donn e par les el ements a[0], . . . , a[N s 1].
Analyse
Le temps de parcours de HEAPSORT est la somme des temps de parcours de la cr eation du
heap (en O(N)), et des N 1 op erations de sift (chacune en O(log i)). Donc, le temps de
159
Algorithme 44 HEAPSORT(a)
Input: Suite a de N el ements ` a cl es entiers
Output: Transformation de a[], . . . , a[r1] telle que a[i].key a[i+1].key pour i < r1
1: BOTTOMUPHEAPCREATE(a);
2: for i = N 1, . . . , 1 do
3: Echanger a[0] et a[i]
4: Swapped true
5: j 0
6: while Swapped = true and j < i do
7: Swapped false
8: if 2j + 1 i (a[j] na aucun ls avec indice < i) then
9: NEXT i
10: else
11: Soit a[] le plus grand ls de a[j] tel que < i
12: end if
13: if a[].key > a[j].key then
14: Echanger a[j] et a[]
15: j
16: Swapped true
17: end if
18: end while
19: end for
160
parcours total dans le pire des cas est
O(N) +
N1
i=1
O(log(i)) = O(N) +O(log(N!))
= O(N log(N)).
Exemple:
8
7
2 5
6
4 3
1
0
1
4 3
7
2
5 6
1
7
2 5
6
4 3
0
1
4 3
2
5 6
8
7
7
1
2 5
6
4 3
0
1
4 3
2
5 6
8
7
7
5
2 1
6
4 3
0
1
4 3
2
5 6
8
7
6.3.4 Priority Queues
Les heaps impl ementent des queues ` a priorit e (Priority Queues) de mani` ere tr` es efcace. Une
queue ` a priorit e est une structure de donn ees abstraite pour stocker des objets avec des cl es. Deux
op erations sont possibles: ENQUEUE ajoute un el ement et DELETEMIN enl` eve l el ement avec la
cl e la plus petite.
De mani` ere analogue, il y a une queue max-priority queue qui impl emente les op erations
Enqueue et DeleteMax. Il est clair quune de ces structures de donn ees peut etre utilis ee pour
impl ementer lautre avec une modication triviale (Exercice). Dans limpl ementation, une queue
` a priorit e pourrait etre une paire consistant en un tableau (array) de longueur variable ainsi que
la longueur du tableau: de cette facon il est possible dajouter des el ements au tableau, ou den
161
enlever. Dans certaines applications un tel tableau peut etre de longueur xe (par exemple pour
les codes de Huffman).
Pour une queue ` a priorit e P, on d enote par Array(P) le tableau correspondant ` a P, par P[i]
le i
eme
el ement du tableau, et par Length(P) la longueur du tableau.
Algorithme 45 ENQUEUE(P, a)
Input: Queue ` a priorit e P, el ement a;
Output: Addition de i ` a P de telle facon que le nouveau tableau reste une queue ` a priorit e
1: Length(P) Length(P) + 1
2: P[Length(P) 1] a
3: SIFTUP (Array(P), Length(P) 1)
Algorithme 46 DELETEMAX(P)
Input: Queue ` a priorit e P
Output: Effacement de l el ement maximal de P de telle facon que le nouveau tableau reste une
queue ` a priorit e; L el ement maximal est retourn e
1: a P[0]
2: P[0] P[Length(P) 1]
3: Length(P) Length(P) 1
4: SIFTDOWN (Array(P), 0)
5: return a
162
7
Algorithmes de graphes
Nous avons etudi e des structures de donn ees pour repr esenter des graphes dans le chapitre 3.
Nous verrons dans ce chapitre plusieurs probl` emes de graphes fondamentaux, et nous intro-
duirons des solutions algorithmiques pour ces probl` emes.
Dans ce chapitre, lensemble des sommets sera en g en eral not e V , celui des ar etes E et le
graphe G, i.e., G = (V, E).
7.1 PARCOURIR DES GRAPHES
Nous etudions dabord le probl` eme de parcours de graphe. Parcourir un graphe veut dire
enum erer tous les sommets atteignables depuis un sommet s donn e, en consid erant dabord les
voisins de s, et it erativement les voisins des voisins, les voisins des voisins des voisins, etc.
Le but est de visiter tous les sommets atteignables, i.e. deffectuer une op eration sur ces
sommets. Cette op eration d epend de lapplication concr` ete en question. Pour donner un exem-
ple simple, si nous voulons compter le nombre de sommets atteignables depuis un sommet s,
nous pouvons parcourir le graphe et la visite dun sommet consisterait alors ` a incr ementer un
compteur.
En g en eral, on veut visiter chaque sommet atteignable exactement une fois, et il faut alors
r esoudre deux probl` emes. Il faut dune part noublier aucun sommet, en sassurant dautre part
quaucun sommet ne soit visit e plus dune fois.
Nous verrons que le premier probl` eme peut etre r esolu en maintenant un ensemble T enum erant
les sommets d ej` a vus mais pas encore trait es. Pour r esoudre le deuxi` eme probl` eme, nous mar-
quons les sommets trait es de facon ` a savoir quels sommets sont encore ` a visiter.
Nous introduirons dabord une solution abstraite pour le probl` eme du parcours de graphe,
avant de sp ecialiser cette solution an dobtenir deux des algorithmes les plus utilis es: Depth
First Search (DFS, profondeur dabord) et Breadth First Search (BFS, largeur dabord). La
diff erence entre les solutions sp ecialis ees concerne lordre dans lequel le parcours a lieu.
Dans la m ethode abstraite nous maintenons un ensemble T qui contient des sommets qui sont
connus atteignables depuis s, mais qui nont pas encore et e visit es. Au d ebut le sommet s est le
seul el ement de lensemble T. Lalgorithme prend un sommet v dans T, le marque puis lenl` eve
163
de T et ajoute ` a T tous ses voisins non marqu es. Dans cette section, N[v] d enote lensemble des
voisins dun sommet v (N comme neighbor, voisin).
Lalgorithme est d ecrit en pseudo-code ci-dessous.
Algorithme 47 ABSTRACTTRAVERSAL(G, s)
Input: Graphe G = (V, E), sommet s V .
Output: Visiter et marquer les sommets de V qui peuvent etre atteints depuis s.
1: T s.
2: Marquer s.
3: while T ,= do
4: Choisir v T.
5: Visiter v.
6: T T v
7: while N[v] ,= do
8: Choisir v
N[v]
9: N[v] N[v] v
10: if v
nest pas marqu e then

11: T T v
12: Marquer v
13: end if
14: end while
15: end while
Th eor` eme 7.1 Quand cet algorithme se termine, lensemble des sommets visit es est exactement
lensemble des sommets atteignables depuis s.
Preuve. Nous montrons que lensemble de sommets marqu es est egal ` a lensemble des sommets
atteignables depuis s. Le r esultat suivra alors parce que chaque sommet marqu e est mis dans
lensemble T juste apr` es quil est marqu e, et chaque sommet qui est mis dans T est aussi visit e,
etant donn e la condition darr et ` a la ligne 3.
Supposons par labsurde que v V soit atteignable depuis s, mais pas marqu e. Il existe un
chemin qui va de s a v, i.e, s = v
0
v
1
v
k1
v
k
= v. Soit le plus petit indice
pour lequel v
nest pas marqu e. On a alors 0 < k. Le sommet v

1
est marqu e, il a donc
et e choisi ` a la ligne 4 ` a un certain moment dans lalgorithme. Mais alors, v
a d u etre choisi ` a la
ligne 8 ` a un certain moment, puis marqu e ` a la ligne 12, une contradiction.
Inversement, supposons par labsurde quil existe un sommet v
V qui est marqu e mais

qui nest pas atteignable depuis s. Soit v
le premier sommet ` a etre marqu e avec cette propri et e.

Donc, v
N[v] pour un certain sommet marqu e v. Puisque v
etait le premier sommet non

atteignable ` a etre marqu e, et v a et e marqu e avant v
, v est atteignable depuis s. Mais alors v
est
atteignable depuis s, une contradiction.
164
Th eor` eme 7.2 Lalgorithme ci-dessus peut etre impl ement e de facon ` a ce que son temps de
parcours soit O([E[).
Preuve. Chaque sommet est ins er e dans T au plus une fois, puisque seuls des sommets non
marqu es sont ins er es dans T (ligne 10). Pour chaque sommet ins er e dans T, au plus tous ses
voisins seront consid ere s aux lignes 714.
D enissons d(v) comme etant le (out-)degree du sommet v. Le nombre de fois que la boucle
de la ligne 7 est execut ee est au plus
vV
d(v) =
_
[E[ si G est orient e,
2[E[ si G est non orient e.
Si les ensembles N[v] sont r ealis es avec une structure de donn ees qui permet dacc eder ` a v
en
temps constant (ligne 8), et denlever ce m eme el ement en temps constant (ligne 9), et de m eme
pour lensemble T, alors le temps de parcours de lalgorithme est O([E[).
Exercice: Quelles structures de donn ees doivent etre utilis ees pour stocker N[v] en permettant
dins erer et denlever des el ements en temps constant?
Nous navons pas sp eci e comment lensemble T devait etre g er e, et cest exactement dans ce
choix que se trouve la diff erence entre les algorithmes concrets de parcours de graphes.
Si nous utilisons un stack, nous obtenons alors lalgorithme Depth First Search (DFS).
Si nous utilisons une le dattente (queue), nous obtenons alors lalgorithme Breadth First
Search (BFS).
7.2 LALGORITHME DEPTH FIRST SEARCH (DFS)
Lalgorithme DFS est obtenu en r ealisant ABSTRACTTRAVERSAL avec T etant un stack. Rap-
pelons que lon peut effectuer sur un stack T les op erations suivantes:
Top(T) : Retourne l el ement sur le haut du stack.
Pop(T) : Enl` eve l el ement sur le haut du stack.
Push(T, v) : ins` ere v sur le haut du stack (push v onto T).
StackEmpty(T) : retourne vrai si T est vide, faux sinon.
7.3 LALGORITHME BREADTH FIRST SEARCH (BFS)
Lalgorithme BFS est la variante de ABSTRACTTRAVERSAL qui utilise pour T la structure de
donn ees queue. Rappelons que lon peut effectuer sur T les op erations suivantes:
165
Algorithme 48 DFS(G, s)
Output: Visiter les sommets de V qui peuvent etre atteints depuis s.
1: Push(T, s)
2: Marquer s
3: while Not StackEmpty(T) do
4: v Top(T)
5: Visiter v
6: Pop(T)
7: while N[v] ,= do
8: Choisir v
N[v]
9: N[v] N[v] v
10: if v

11: Push(T, v
)
12: Marquer v
13: end if
14: end while
15: end while
Head(T) retourne le premier el ement de la queue.
Dequeue(T) enl` eve le premier el ement de la queue.
Enqueue(T, v) ins` ere v ` a la n de la queue.
QueueEmpty(T) retourne vrai si et seulement si T est vide.
Exercices:
Modier lalgorithme BFS pour quil retourne pour chaque sommet sa distance par rapport
` a s.
Modier les algorithmes BFS et DFS pour quils retournent pour chaque sommet la taille
de sa composante connexe.
Construire une structure de donn ees qui peut maintenir la liste pr ec edente dans le cas
dun graphe dynamique auquel on peut ajouter des sommets (mais duquel on ne peut pas
enlever de sommets), en gardant pour chaque sommet un pointeur sur un autre sommet
dans la composante connexe. Quel est le temps de parcours de votre algorithme?
7.4 TRI TOPOLOGIQUE (TOPOLOGICAL SORTING)
Supposons que nous voulons ecrire un chapitre sur les algorithmes de graphes dans un sup-
port de cours dalgorithmique. Nous avons tout dabord une liste de sujets que nous aimerions
166
Algorithme 49 BFS(G, s)
Output: Visiter les sommets de V qui peuvent etre atteints depuis s.
1: Enqueue(T, s)
2: Marquer s
3: while Not QueueEmpty(T) do
4: v Head(T)
5: Visiter v
6: Dequeue(T)
7: while N[v] ,= do
8: Choisir v
N[v]
9: N[v] N[v] v
10: if v

11: Enqueue(T, v
)
12: Marquer v
13: end if
14: end while
15: end while
traiter, comme lalgorithme BFS, le tri topologique, etc. Evidemment, nous ne pouvons pas
traiter les sujets dans nimporte quel ordre; par exemple avant d etudier lalgorithme BFS, il est
obligatoire de comprendre ce que cest quun parcourt de graphe; de mani` ere g en erale, les su-
jets ont comme pr ealable dautres sujets. Nous pouvons d ecrire ces d ependances ` a laide dun
graphe: chaque sommet correspond ` a un sujet, et on met une ar ete a b sil est n ec essaire (ou
souhaitable) de traiter le sujet a avant le sujet b.
Pour lexemple du livre dalgorithmique, on aura peut- etre un graphe comme le suivant:
167
Parcourt de graphes
DFS BFS
Tri topologique
Dijkstra
MBF
Flux de rseau
Plus court chemin
Maximum Bipartite Matching
Le probl` eme que lauteur doit r esoudre, est le suivant: dans quel ordre dois-je traiter les sujets
an de ne jamais traiter un sujet avant davoir trait e les pr ealables n ecessaires. En termes du
graphe, la t ache est: trouver un ordre des sommets tel que pour toute paire de sommets a, b V ,
si a vient avant b, alors il ny a pas dar ete b a. Cest un probl` eme de tri topologique.
Plus formellement, le tri topologique dun graphe orient e acyclique G = (V, E) consiste ` a
donner un ordre aux sommets v
1
, . . . , v
n
de G tel que (v
i
, v
j
) E implique que i < j. Voici un
autre exemple:
6
9
8
10
2
3
7
5
4
1
Un tri topologique possible dun tel graphe est le suivant:
168
10 9 2 3 7 1 8 4 5 6
Donc nous prenons les sommets de droite ` a gauche dans la gure ci-dessus pour obtenir
lordre voulu. Parmi les diff erentes applications de cette m ethode de tri, signalons les exemples
suivants :
Job scheduling : une famille de t aches (jobs) doit etre accomplie avec certaines contraintes
quant ` a lordre dans lequel ceci doit etre fait. On utilise alors un graphe orient e acyclique
o` u les sommets sont les t aches et une ar ete (u, v) repr esente la contrainte la t ache u doit
etre effectu ee avant la t ache v.
Les parenth` esements valables avec 3 paires de parenth` eses sont en bijection avec tous les
tris topologiques possibles du graphe suivant:
La bijection sobtient en associant aux sommets de gauche des parenth` eses ouvertes ` a droite
et aux sommets de droite des parenth` eses ouvertes ` a gauche. Ce cas est facile a g en eraliser.
Comment trouver un ordre topologique dun graphe? Pour reprendre lexemple du cours
dalgorithmique ci-dessus, une approche simple est de dabord traiter tous les sujets sans pr ealables,
ensuite les sujets qui ont juste comme pr ealables les sujets d ej` a trait es et ainsi de suite.
En effet, cette approche est lid ee de base de lalgorithme TOPSORT que nous discuterons
maintenant plus en d etails.
Dans lalgorithme suivant nous donnons des indices aux sommets v. Lindice du sommet
v est d enot e par v.label. Nous utiliserons une queue Q qui contiendra lensemble de tous les
sommets visit es jusqu` a pr esent qui pourraient etre utilis es en tant que prochain el ement dans le
tri topologique. Lalgorithme traverse les sommets d ej` a dans pr esents dans Q, et les enl` eve du
graphe. Si pendant cette proc edure le in-degr e dun sommet est r eduit ` a zero, alors ce sommet
est ajout e ` a Q.
169
Algorithme 50 TOPSORT(G)
Input: Graphe acyclique orient e G = (V, E).
Output: Tri topologique de G, donn e par les indices des sommets v.label.
1: Initialiser v.Indegree pour tout v V (e.g., via DFS).
2: t 0
3: for i = 1, . . . , n do
4: if v
i
.Indegree = 0 then
5: Enqueue(Q, v
i
)
6: end if
7: end for
8: while Not QueueEmpty(Q) do
9: v = Head(Q)
10: Dequeue(Q)
11: t t + 1
12: v.label = t
13: for w N[v] do
14: w.Indegree w.Indegree 1
15: if w.Indegree = 0 then
16: Enqueue(Q, w)
17: end if
18: end for
19: end while
170
Rappelons que N[v] d enote lensemble des voisins du sommet v.
Th eor` eme 7.3 Le temps de parcours de TOPSORT est O([V [ + [E[), et il a besoin de O([V [)
m emoire en plus.
Preuve. Exercice.
Exercice. En quoi consiste la visite dun sommet si lon veut utiliser DFS pour initialiser
v.Indegree dans le pas 1 de TOPSORT?
7.5 CHEMINS LES PLUS COURTS
Supposons que nous disposons dune carte du r eseau routier du canton de Vaud. Nous nous
trouvons ` a Forel et nous aimerions trouver les plus courts chemins de Forel ` a tous les autres
villages du canton. Nous pouvons mod eliser ce probl` eme comme un probl` eme de graphe: chaque
village est un sommet et les routes sont des ar etes entre les villages. Chaque ar ete (route entre
villages) a une longueur. Le probl` eme est alors de trouver pour chaque sommet x, le chemin
du sommet de d epart (Forel dans lexemple) arrivant ` a x tel que la somme des distances sur le
chemin soit minimale.
Nous d ecrivons dabord le probl` eme plus formellement. Soit G = (V, E) un graphe orient e
avec une fonction poids c: E R
>0
. Donc chaque ar ete e a un certain poids c(e). Nous
voulons trouver les chemins les plus courts dun sommet s V donn e ` a tous les sommets v V
atteignables depuis s. Il faut pr eciser ici quelle notion nous attribuons ` a la d enition de plus
court. Le co ut dun chemin est la somme des poids des ar etes sur le chemin et par chemin le
plus court, on entend le chemin pour lequel le co ut est minimal.
Exemple: V = v
1
, . . . , v
7
; s = v
1
171
1
1
1
1 2
2
3
3
3
4
4
5
5
6
7
7
(v): Longueur du chemin le plus court du sommet 1 au sommet v, (v) = si v nest pas
connect e ` a s.
(v
1
) = 0; (v
2
) = 1; (v
3
) = 1;
(v
4
) = ; (v
5
) = 3; (v
6
) = 12;
(v
7
) = 7;
Lalgorithme de programmation dynamique suivant, d u ` a Dijkstra (1959) calcule les chemins
les plus courts de s ` a tous les v V auxquels s est connect e. Il maintient un ensemble T qui,
` a la n du parcours de lalgorithme, contient tous les sommets dans V atteignables depuis s. A
chaque etape pour tout w T la valeur (w) sera la longueur du chemin le plus court de s ` a w.
Th eor` eme 7.4 Lalgorithme de Dijkstra est juste, i.e., la valeur (w) d etermin ee est en effet la
longueur du plus court chemin de s ` a w pour tout w V .
Preuve. Pour la preuve, notons
vrai
(v) la vraie longueur du plus court chemin de s ` a v. Il sagit
donc de montrer qu` a la n de lalgorithme, nous avons (v) =
vrai
(v) pour tout v V . Pour
simplier les notations, nous posons c(v, w) = si (v, w) / E.
Nous montrons dabord que lalgorithme ne se termine pas avant que T couvre toute la com-
posante connexe de s. Nous montrons ceci par labsurde. Notons S la composante connexe de
s. Si T est un sous-ensemble propre non-vide de S, alors il existe un voisin w de T. Soit v T
tel que (v, w) E. On a (v) < (puisqu aucun el ement v avec (v) = nest jamais ajout e
` a T) et c(v, w) < et donc (w) (v) + c(v, w) < . Donc w peut etre choisi ` a l etape 15,
et il ne sagit alors pas de lit eration nale. Donc ` a la n de lalgorithme, on a T = S.
172
Algorithme 51 DIJKSTRA(G, s)
Input: Graphe orient e G = (V, E) avec fonction de poids c: E R
>0
, sommet s V .
Output: Pour tout v V la distance la plus courte (v) entre s et v.
1: for v V s do
2: (v)
3: end for
4: (s) 0, T , v s
5: while v ,= NULL and (v) ,= do
6: T T v
7: for w V T do
8: if (v, w) E then
9: d (v) +c(v, w)
10: if d < (w) then
11: (w) d
12: end if
13: end if
14: end for
15: Choisir v dans V T de facon ` a ce que (v) soit minimal,
poser v := NULL si V T = .
16: end while
Montrons maintenant que pour tout v T, (v) est la longueur dun chemin de s ` a v; il sen
suivra que (v)
vrai
(v).
Pour montrer cela, on proc` ede par induction sur [T[. Il ny a rien ` a montrer pour [T[ = 0.
Supposons maintenant quun el ement w est ajout e ` a T. La propri et e est vraie sur T w par
hypoth` ese dinduction et il suft donc de la montrer pour w. La valeur de (w) vaut (w) =
(v) + c(v, w) pour un certain v T; par hypoth` ese dinduction, un chemin s v de
longueur (v) existe. Le chemin s v w est alors de longueur (v) +c(v, w) = (w),
comme voulu.
Pour la suite, nous aurons besoin de l egalit e
(w) = min
vT
_
(v) +c(v, w)
_
,
qui est vraie parce que la boucle des lignes 7 - 14 met ` a jour (w) pour chaque v ajout e ` a T.
Montrons que pour tout v T, (v)
vrai
(v) (et que alors (v) =
vrai
(v)). Nous proc edons
de nouveau par r ecurrence sur [T[. Nous consid erons l etape o` u w V est ajout e ` a T. Soit
s = w
0
w
1
w
m
= w un plus court chemin de s ` a w.
Il nous faut dabord voir que alors w
m1
T. (En fait nous montrerons m eme que w
0
, w
1
, . . . , w
m1

173
T). Soit, par labsurde, 0 < k < m le plus petit indice avec w
k
/ T. Alors
(w)
vrai
(w)
>
vrai
(w
k
)
=
vrai
(w
k1
) +c(w
k1
, w
k
)
= (w
k1
) +c(w
k1
, w
k
) (par hypoth` ese dinduction)
min
vT
_
(v) +c(v, w
k
)
_
= (w
k
),
contradisant le choix de w ` a l etape 15: w
k
aurait et e un meilleur choix.
Donc w
m1
T, et alors
vrai
(w) =
vrai
(w
m1
) +c(w
m1
, w)
= (w
m1
) +c(w
m1
, w) (par hypoth` ese dinduction)
min
vT
_
(v) +c(v, w)
_
= (w),
comme voulu.
Voici le r esultat concernant la vitesse de lalgorithme:
Th eor` eme 7.5 Lalgorithme de Dijkstra a un temps de parcours O(n
2
) et a besoin de O(n) de
m emoire, o` u n = [V [.
Preuve. La boucle while ` a la ligne 5 est execut ee au plus n fois. A chaque etape tous les voisins
de v en dehors de T sont consid er es aux lignes 813. Le nombre de tels sommets est au plus
d(v), le out-degree de v. Ainsi, les lignes 813 sont execut ees [E[ fois au total.
Ligne 15: Sans une queue ` a priorit e, tous les el ements de V T doivent etre inspect es, le temps
de parcours de la ligne 15 sur tout lalgorithme est donc O(n
2
). Puisque [E[ = O(n
2
), le premier
r esultat sensuit.
Finalement, nous devons stocker (v) pour tout v V , il nous faut dont O(n) m emoire en
plus (puisque [V [ = n). Remarquons que nous ne prenons pas en compte le fait que les nombres
(v) deviendront plus grands quand n augmente, et n ecessiteront donc plus de m emoire.
Avec la bonne structure de donn ees (Fibonacci-Heaps), le temps de parcours peut etre r eduit
` a O(nlog(n) +[E[). (sans preuve)
Exercice: Modier lalgorithme de Dijkstra pour quil retourne pour chaque sommet son pr ed ecesseur
sur un chemin le plus court depuis s. (Au lieu de simplement retourner la longueur du chemin le
plus court). Indice: Ajouter un membre pred (pour m emoriser le pr ed ecesseur sur le plus court
chemin) aux sommets.
174
7.6 LALGORITHME DE MOORE-BELLMAN-FORD
Le grand d esavantage de lalgorithme de Dijkstra est que les co uts des ar etes doivent etre non-
n egatifs.
Il existe un algorithme qui na pas cette restriction. Il sagit de lalgorithme de Moore-
Bellman-Ford dans lequel les co uts peuvent etre n egatifs. Cependant, la seule exigence est la
non-existence de cycles de longueur n egative.
Remarquons que cette derni` ere condition est en fait une restriction essentielle, plut ot quune
restriction de lalgorithme: sil y a un cycle de poids n egatif, alors le probl` eme nest pas bien
pos e; dans ce cas, un chemin de poids arbitrairement petit peut etre construit simplement en
tournant au rond dans ce cycle.
Algorithme 52 MBF(G, s)
Input: Graphe orient e G = (V, E) avec fonction poids c: E R qui ne contient pas de cycles
de longueur n egative, s V .
Output: Pour tout v V la distance la plus courte (v) entre s et v.
1: for v V s do
2: (v)
3: end for
4: (s) 0
5: for i = 1, . . . , n 1 do
6: for (v, w) E do
7: d (v) +c(v, w)
8: if d < (w) then
9: (w) d
10: end if
11: end for
12: end for
Th eor` eme 7.6 Lalgorithme de Moore-Bellman-Ford est correct et calcule son output en util-
isant O(mn) op erations, o` u m = [E[ et n = [V [.
Preuve. Lassertion sur le temps de parcours est evidente. Montrons ` a pr esent que lalgorithme
est correct:
Remarquons que pendant le parcours de lalgorithme, si (v) ,= , on a toujours quil existe
un chemin s v de longueur (v) pour nimporte quel v V . On voit cela par induction
sur le nombre de fois que l etape 9 est execut ee: il faut alors montrer que la mise ` a jour
(w) d = (v) +c(v, w)
175
ninvalide pas lafrmation. Cest vrai parce que par hypoth` ese dinduction, on a un chemin
s v de longueur (v). Mais alors le chemin s v w est de longueur
(v) +c(v, w), comme d esir e.
Montrons maintenant que les longueurs trouv ees sont les plus courtes possibles.
Remarquons dabord quil suft de prouver que lalgorithme trouve la longueur du plus court
chemin passant par n 1 ar etes, car il existe toujours un chemin le plus court de s ` a w qui
utilise au plus n 1 ar etes. En effet si un chemin en avait plus que n 1, alors au moins un
sommet apparatrait au moins deux fois sur le chemin, il devrait donc contenir un cycle. Ce cycle
pourrait etre enlev e, sans augmenter le poids du chemin (puisquil ny a pas de cycles n egatifs).
Ce proc ed e pourrait etre continu e jusqu` a ce que chaque sommet sur le chemin apparaisse au
plus une fois, r esultant en un plus court chemin passant par au plus n 1 ar etes.
Etant donn e lafrmation pr ec edente, il suft de montrer que apr` es la i-` eme it eration de la
boucle des lignes 5-12, (v) est inf erieur o` u egal ` a la longueur du plus court chemin s v
passant par au plus i ar etes.
On prouvera cela par induction sur i. Soit
vrai,i
(v) la longueur du plus court chemin s
v passant par au plus i ar etes. Soit
i
(v) la valeur de (v) d etermin ee par lalgorithme ` a la
n de la i-` eme it eration.
Soit
i,w
(v) la valeur de (v) ` a la ligne 7 lorsque la variable w = w et i = i. Notons que
pendant la i-` eme it eration, on a alors toujours
i1
(v)
i,w
(v), vu que (v) naugmente jamais.
`
A la i-` eme it eration, on a
vrai,i
(w) = min
vrai,i1
(w), min
(v,w)E
vrai,i1
(v) +c(v, w)
min
i1
(w), min
(v,w)E
i1
(v) +c(v, w) (hyp. dinduction terme par terme)
min
i1
(w), min
(v,w)E
i,w
(v) +c(v, w) (comme
i1
(v)
i,w
(v))
=
i
(w),
prouvant lafrmation et terminant la preuve.
7.7 FLUX DE R
ESEAU
D enition. Un r eseau (network) (G, c, s, t) est un graphe orient e G = (V, E) avec une fonction
de capacit e c: E R
>0
et deux sommets distingu es s V et t V appel es respectivement
source et sink. Nous supposons que tout autre sommet dans V est sur un chemin de s vers t.
D enition. Un ux (ow) est une application f : E R
0
telle que:
176
1. Pour tout e E on a f(e) c(e) (contrainte de capacit e)
2. Pour tout v V s, t:
eE(v,V \{v})
f(e) =
eE(V \{v},v)
f(e),
i.e., tout ce qui rentre dans le sommet v doit aussi en sortir (sauf pour s et t).
On peut par exemple avoir un r eseau de tuyaux (les ar etes). On veut faire couler de leau de
s vers t. La contrainte de capacit e (condition 1 dans la d enition de ow) exprime alors le fait
que chaque tuyau a un d ebit (capacit e) maximal (en litres par secondes), et la condition 2 dit que
` a chaque sommet (p.e. bifurcation de tuyaux), il entre autant deau par unit e de temps qui sort.
Dans le r eseau suivant, les sommets sont des villes et les capacit es des capacit es de transport
entre les villes. Ici, on a s = Liverpool et t = Istanbul.
London Milano
Eindhoven
Lyon
8
2
15
3
10
11
7
4
14
3
7
Liverpool Istanbul
Voici un ux possible sur ce r eseau:
London Milano
Eindhoven
Lyon
Liverpool Istanbul
1/10
3/3
6/7
8/8
3/11
14/14
4/7
0/2 2/4
12/15
2/3
177
D enition. La valeur dun ux f est
[f[ =
eE(s,V \{s})
f(e)
eE(V \{s},s)
f(e).
Donc [f[ donne la quantit e nette transport ee de s ` a t.
Dans lexemple ci-dessus on a [f[ = 14.
D enition. Etant donn e un r eseau, un ux maximal est un ux qui a la plus grande valeur parmi
tous les ux possibles.
Remarquons quun ux maximal nest pas forc ement unique, cest-` a-dire quil peut y avoir
plusieurs ux qui ont la valeur maximale. Nous nous int eressons au probl` eme suivant:
Probl` eme. Etant donn e un r eseau, trouver un ux maximal.
La notion de cut nous fournira un crit` ere de maximalit e dun ux.
D enition. Un cut (S, T) avec S, T V est une partition de V : S T = , S T = V , avec
s S, t T. Lensemble des ar etes allant de S ` a T est
E(S, T) := (S T) E.
Pour x S on pose E(x, T) := E(x, T) (de m eme pour S et y T).
Dans lexemple ci-dessus, prenons pour S les villes en Angleterre et pour T les autres villes,
i.e., S = London, Liverpool et T = V S. La masse partant de Liverpool et arrivant ` a
Istanbul doit bien passer la fronti` ere anglaise ` a un moment donn e. Le lemme suivant exprime
cette observation.
Lemme 2 Soit (G, c, s, t) un r eseau, (S, T) un cut et f un ux. Alors
[f[ =
eE(S,T)
f(e)
eE(T,S)
f(e).
Preuve.
[f[ =
eE(s,V \{s})
f(e)
eE(V \{s},s)
f(e)
=
vS
_
_
eE(v,V \{v})
f(e)
eE(V \{v},v)
f(e)
_
_
178
=
vS
_
_
_
_
xS
(v,x)E
f((v, x)) +
xT
(v,x)E
f((v, x))
xS
(x,v)E
f((x, v))
xT
(x,v)E
f((x, v))
_
_
_
_
=
v,xS
(v,x)E
f((v, x)) +
vS,xT
(v,x)E
f((v, x))
v,xS
(x,v)E
f((x, v))
vS,xT
(x,v)E
f((x, v))
=
vS,xT
(v,x)E
f((v, x))
vS,xT
(x,v)E
f((x, v))
=
eE(S,T)
f(e)
eE(T,S)
f(e)
Aussi, la capacit e transport e de Liverpool ` a Istanbul ne peut pas exc eder la capacit e de la
fronti` ere anglaise. Plus formellement,
Lemme 3 Soit (G, c, s, t) un r eseau, (S, T) un cut et f un ux. Alors
[f[
eE(S,T)
c(e).
Preuve. Suit du lemme pr ec edent, puisque
e E: 0 f(e) c(e).
Remarquons quon peut choisir un cut et un ux quelconque dans le lemme pr ec edent. En

particulier, le lemme implique que le ux maximal ne peut pas etre plus grand que le cut minimal.
Nous allons voir quen fait, le ux maximal est egal au cut minimal. Pour prouver cette
assertion nous avons besoin de nouvelles notations:
Pour une ar ete e = (u, v) E donn ee, lar ete inverse de e est lar ete

e:= (v, u).
179
A un ux f on peut associer le graphe r esiduel (G
f
, c
, s, t) de f. Les ar etes du graphe

r esiduel sont
E
:= e [ e E f(e) < c(e)
e[ e E f(e) > 0.
En francais, on met une ar ete entre deux sommets pour chaque ar ete pour laquelle la capacit e
nest pas epuis ee par le ux, et on met une ar ete en sens inverse pour chaque ar ete de ux non-
nul. (Techniquement, le graphe r esiduel est un multigraphe, i.e. il peut y avoir plusieurs ar etes
entre deux sommets. Nous ignorons ce probl` eme ici.)
c
f(e
)
:=
_
c(e
) f(e
) si e
E,
f(e) si e
e pour un e E.
On a c
f
(e) > 0 pour tout e E
.
Le graphe r esiduel G
f
repr esente donc les diff erentes facons dont on peut modier le ux
f(e) sur chaque ar ete. Si f(e) < c(e) alors on peut augmenter f(e) puisquil na pas atteint la
capacit e de lar ete. Si f(e) > 0 alors on peut diminuer le ux sur lar ete e.
Un chemin f-augmentant P du r eseau (G, c, s, t) par rapport au ux f est un s-t-chemin dans
le graphe r esiduel G
f
. f est augment e par R
>0
via P, si pour toute ar ete e
de P on a la
propri et e suivante : si e
E, alors f(e) est augment e de , si e
e, alors f(e) est diminu e de

.
Le graphe r esiduel pour un certain ux repr esente les modications possibles pour ce ux.
Exemples:
180
5
11
1
12
3
12
7
3
11
4
1
9
5
11
5
8
3
4
5
12
7
3
11
4
5
11
11
15
19
12/12
1/4 7/7 10
11/14
4/4
12/13
12/12
1/4 7/7
15/20
10 4/9
11/14
4/4
8/13
0/9
11/16
11/16
19/20
s
s
s
s
t
t
t
t
v
1
v
1
v
1
v
1
v
2
v
2
v
2
v
2
v
3
v
3
v
3
v
3
v
4
v
4
v
4
v
4
La valeur du ux a et e augment ee de 4. Augmenter de R
>0
augmente la valeur du ux
de (en g en eral). Restriction: ne doit pas etre plus grand quune capacit e r esiduelle.
Th eor` eme 7.7 Soit f un ux dans un r eseau (G, c, s, t). Les assertions suivantes sont equivalentes:
(a) f est un ux maximal,
181
(b) G
f
ne contient pas de chemins augmentants,
(c) Il existe un cut (S, T) avec
[f[ =
eE(S,T)
c(e).
Preuve. (a) (b): Supposons que G
f
contient un chemin augmentant P. Soit := min
e
E
c
f
(e
).
Par d enition de c
f
on a > 0. Donc, la valeur de f serait diminu ee en augmentant f via P de
, une contradiction.
(b) (c): G
f
ne contient pas de chemins augmentants, donc t nest pas atteignable depuis
s dans G
f
. Soit S lensemble des sommets atteignables dans G
f
depuis s, donc s S, t / S,
donc (S, T), T = V S, est un cut. Par d enition de c
f
:
e E(S, T) f(e) = c(e)
e E(T, S) f(e) = 0
En effet, si on navait pas f(e) = c(e) pour un certain e (S, T), alors il y aurait une ar ete dans
G
f
entre S et T, donc un sommet de T serait atteignable depuis s, une contradiction. De m eme
pour lautre egalit e. Par le Lemme 7.1: [f[ =
eE(S,T)
c(e).
(c) (a): Suit du Lemme 7.2.
Ce r esultat implique le c el` ebre Th eor` eme de Ford-Fulkerson qui suit:
Th eor` eme 7.8 (Ford-Fulkerson) La valeur du ux maximal dans un r eseau est egale ` a la
valeur du cut minimal du r eseau.
Lalgorithme suivant est d eriv e directemement de la preuve du th eor` eme de Ford-Fulkerson:
Algorithme 53 MAXFLOWMINCUT(G, c, s, t)
Input: R eseau (G, c, s, t)
Output: Flow maximal dans le r eseau de s ` a t.
1: for e E do
2: f(e) = 0
3: end for
4: Construire un chemin f-augmentant P; STOP si un tel chemin nexiste pas.
5: Poser := min
e
c
f
(e), o` u e parcourt toutes les ar etes de P.
6: Augmenter f via P de .
7: GOTO Etape 4.
Le temps de parcours de cet algorithme est probl ematique. Si les capacit es sont des valeurs
enti` eres, alors il est possible dobtenir un algorithme avec un temps de parcours exponentiel.
Voir lexemple ci-dessous.
182
s
s
s
u
u
u
v
v
v
t
t
t
10
6
10
6
10
6
10
6
10
6
10
6
1
1
1
1
1
1
1
1
1
10
6
1
10
6
1
10
6
1
10
6
1
10
6
1
10
6
1
Quand des capacit es irrationnelles sont utilis ees, il nest m eme pas certain que lalgorithme
termine. Le probl` eme est que nous navons rien dit sur comment ces chemins peuvent etre
construits. Si nous utilisons un chemin augmentant le plus court ` a chaque etape (par exemple, en
utilisant lalgorithme BFS), alors on peut montrer que lalgorithme termine apr` es au plus mn/2
augmentations. Puisque chaque recherche BFS n ecessite un temps de parcours de lordre de
O(m), on obtient un temps de parcours O(m
2
n) pour lalgorithme.
Nous ne prouvons pas ce r esultat ici.
183
Exemple: Maximiser le ux de s ` a t ci-dessous:
s
t
/3
/7
/5
/2
/2
/5 /4
/6
0
0
1
0
0
1
0
1
On trouve un chemin augmentant et lam elioration correspondante:
s
t
/3
/7
/5
/2
/2
/5 /4
/6
0
0
1
0
0
1
0
1
=
s
t
/3
/7
/5
/2
/2
/5 /4
/6 0
0
1
0
1
3
3
4
On r ep` ete la proc edure:
184
s
t
/3
/7
/5
/2
/2
/5 /4
/6 0
0
1
0
1
3
3
4
=
s
t
/3
/7
/5
/2
/2
/5 /4
/6
1
0
3
3
4
3
2
2
Encore une fois:
s
t
/3
/7
/5
/2
/2
/5 /4
/6
1
0
3
3
4
3
2
2
=
s
t
/3
/7
/5
/2
/2
/5 /4
/6
4
3
4
4
0
0
3
3
Encore:
185
s
t
/3
/7
/5
/2
/2
/5 /4
/6
4
3
4
4
0
0
3
3
=
s
t
/3
/7
/5
/2
/2
/5 /4
/6
4
3
0
5
5
1
4
4
Finalement, on obtient le ux optimal, comme le montre le cut:
s
t
/3
/7
/5
/2
/2
/5 /4
/6
4
3
0
5
5
1
4
4
Min Cut
186
7.8 APPLICATION: MAXIMUM BIPARTITE MATCHING
Consid erons le probl` eme suivant: etant donn e un ensemble de m el` eves, et un ensemble de n
chambres, et pour chaque el` eve la liste des chambres qui lint eressent, donner ` a chaque el` eve
une chambre de telle facon quautant d el` eves que possible soient satisfaits. (Une chambre peut
contenir exactement un el` eve).
Cest le probl` eme de maximum bipartite matching.
En g en eral: etant donn e un graphe biparti avec m sommets sur la gauche et n sommets sur la
droite, un matching de taille dans le graphe consiste en
sommets de gauche,
sommets de droite,
un sous-ensemble de ar etes qui connecte chacun des sommets de gauche ` a un des
sommets de droite et vice versa.
Un maximum bipartite matching est un matching pour lequel est aussi grand que possible. Nous
exposons une solution a ce probl` eme bas e sur lalgorithme de ux de r eseau:
Soient L et R les ensembles de sommets sur la gauche et sur la droite. Ajouter des sommets
s et t, pour lesquels s est connect e a tous les sommets dans L, et tous les sommets dans R
sont connect es ` a t. On oriente tous les sommets de la gauche vers la droite, et on leur donne
une capacit e de 1. On peut alors appliquer lalgorithme MAXFLOWMINCUT du paragraphe
pr ec edent pour trouver un ux maximal auquel correspondra alors un matching maximal.
Exemple: Supposons que nous avons 4 etudiants et 5 chambres. Nous commencons avec un
graphe biparti qui indique quelles sont les chambres par lesquelles est int eress e chaque el` eve:
Etudiants
Chambres
187
Nous ajoutons les sommets s et t, orientons le graphe et ajoutons les capacit es, comme d ecrit
ci-dessus. On obtient ainsi un r eseau:
1
1
1
Etudiants
Chambres
s
1
1
1
1
1
1
1
1
1
t
1
1
1
1
Nous construisons ensuite un ux f:
0/1
1/1
1/1
Etudiants
1/1
0/1
0/1
0/1
1/1
1/1
t
1/1
Chambres
0/1
1/1
1/1
1/1
s
0/1
0/1
Nous construisons le graphe r esiduel par rapport ` a f:
188
1
1
1
1
1
1
1
1
s
1
1
1
Etudiants
Chambres
1
1
1
1
1
t
Nous trouvons un chemin f-augmentant:
1
s
1
1
1
1
1
1
1
1
Etudiants
Chambres
1
1
1
1
t
1
1
1
Et obtenons ainsi un nouveau ux:
189
1/1
1/1
1/1
s
1/1
1
Etudiants
2
3
4
1/1
1/1
1/1
1/1
0/1
0/1
d
e
1/1
t
Chambres
1/1
a
b
c
1/1
1/1
0/1
Ce ux est maximal: Le cut S = s, T = V S le montre.
Le matching correspondant est le suivant:
el` eve chambre
1 c
2 a
3 b
4 e
7.9 ARBRES COUVRANTS MINIMAUX
Supposons que nous aimerions connecter des sites A, B et C par cable de telle facon que tout le
monde puisse communiquer avec tout le monde. Le co ut des liens est comme suit:
lien co ut
A B 35
B C 127
C A 50
Une solution evidente est de relier chaque site ` a chaque site, ce qui revient dans notre cas ` a un
co ut de 35 + 50 + 127 = 212.
On peut faire mieux. En ne liant que A et B, et A et C, on ne paye que 35 + 50 = 85, et le
probl` eme est aussi r esolu: si B veut parler ` a C, il suft de passer le message ` a A qui le passera ` a
C.
Le cas g en eral du probl` eme ci-dessus est un probl` eme de graphe, il sagit de trouver un
graphe connexe qui lie tous les sommets, tout en minimisant les co uts. Voici un enonc e formel
du probl` eme:
190
Etant donn e un graphe G = (V, E) avec fonction de poids w: E R
>0
, trouver un arbre
T = (V, E
) avec E
E et tel que
eE
w(e)
est minimal. Un tel arbre est appel e un arbre couvrant minimal (minimum spanning tree, MST).
(Pourquoi cherche-t-on un arbre, et non pas un graphe quelconque connexe minimisant le co ut?
Cest simplement parce que le meilleur graphe est toujours un arbre.)
Nous voulons trouver un arbre couvrant minimal pour un graphe G donn e. Les arbres cou-
vrants minimaux sont tr` es importants en pratique, par exemple pour r esoudre le probl` eme de
connecter un ensemble de sites en utilisant aussi peu de cable que possible, comme donn e dans
lexemple ci-dessus.
Nous etudierons deux solutions ` a ce probleme: lalgorithme de Kruskal et lalgorithme de
Prim.
7.9.1 Lalgorithme de Kruskal
Lalgorithme glouton suivant est d u ` a Kruskal (1956). Soit E lensemble des ar etes de G.
Algorithme 54 MINSPANKRUSKAL(G, w)
Input: Graphe G = (V, E) avec fonction de poids w: E R
>0
Output: Ensemble E
dar etes qui forment un arbre couvrant minimal de G.

1: Trier E = e
1
, . . . , e
m
de telle facon que w(e
1
) w(e
2
) w(e
m
).
2: E

3: for i = 1, . . . , m do
4: if le graphe (V, E
e
i
) est acyclique then
5: E
e
i
6: end if
7: end for
Encore une fois, et dailleurs ` a chaque fois quun nouvel algorithme apparat, les questions
essentielles auxquelles il faut r epondre sont : est-il juste? Comment limpl ementer de mani` ere
efcace? Quel est le temps de parcours?
Lemme 4 Soit G = (V, E) un graphe avec une de fonction de poids et E
E un ensemble
dar etes. Sil existe un arbre T = (V, E
T
) tel que E
E
T
, et e E est la plus petite ar ete
(cest-` a-dire lar ete de poids minimal) dans EE
qui ne cr ee pas de cycle lorsquelle est ajout ee

` a E
, alors il existe un arbre couvrant minimal T
= (V, E
T
) tel que E
e E
T
.
Notons que ce lemme prouve que lalgorithme de Kruskal est juste: lalgorithme utilise ce
lemme en commencant avec E
= .
191
Preuve. Si e E
T
alors on peut prendre T
= T et la proposition est v eri ee. Supposons

maintenant que e / E
T
. Si on ajoute e ` a E
T
on cr ee un cycle (puisquun arbre sur n sommets
a toujours n 1 ar etes, donc en ajoutant une ar` ete ` a T il ne sera plus un arbre et aura donc un
cycle). Ce cycle a une ar ete e
1
qui appartient ` a E E
(puisque le fait dajouter e ` a E
ne cr ee
pas de cycle par supposition). Ajouter e
1
` a E
naurait pas cr e e de cycle, et donc puisque e est la

plus petite ar ete ` a avoir cette propri et e, on a w(e
1
) w(e). Si on remplace e
1
par e dans T on
cr ee un autre arbre couvrant qui contient e.
Puisque w(e
1
) w(e), le co ut de cet arbre couvrant est au plus le co ut de T, il est donc aussi
minimal.
Quelle est limpl ementation la plus simple de lalgorithme de Kruskal?
Trier les m ar etes en temps O(mlog(m)) (nous avons vu comment faire dans le chapitre
pr ec edent),
pour chaque ar ete en ordre, tester si elle cr ee un cycle dans la for et que nous avons constru-
ite jusqu` a pr esent. Si oui on lefface, sinon on lajoute a notre for et. Avec un BFS/DFS,
on peut faire le test en temps O(n) (puisque larbre a au plus n sommets et au plus n 1
ar etes).
Le temps total est O(mn).
Peut-on faire mieux? OUI, en utilisant la Structure de donn ees Union Find.
Que fait lalgorithme de Kruskal?
Il commence avec une for et
1
dans laquelle chaque el ement est un sommet. Il connecte deux
composantes de la for et en utilisant une ar ete minimale, si les deux sommets de cette ar ete ne
sont pas dans la m eme composante (i.e. aucun cycle nest cr ee). Donc, si nous pouvons savoir
rapidement quels sommets sont dans quelles composantes, ne navons pas besoin de tester la
non-existence de cycles!
Algorithme 55 ABSTRACTMINSPANKRUSKAL(G, w)
1: Stocker les ar etes dans un heap
2: T
3: while [T[ < n 1 do
4: (v, w) lar ete minimale du heap
5: if composante(v) ,= composante(w) then
6: ajouter (v, w) ` a T
7: r eunir les composantes de v et de w en une seule composante.
8: end if
9: end while
1
Une for et est une collection darbres.
192
Si nous pouvons faire le test ` a la ligne 5 en temps O(log(n)) et lunion ` a la ligne 7 en O(1),
alors un arbre couvrant minimal peut etre trouv e en temps O(mlog(n))! (Il faut un temps O(m)
pour cr eer un heap, et O(mlog(n)) pour toutes les op erations ` a lint erieur de la boucle).
Pour faire les tests et les unions en temps O(log(n)), nous maintenons les sommets dans une
structure de donn ees Union Find.
7.9.2 La structure Union Find
Nous avons besoin dune m ethode rapide pour tester si une ar ete relie deux sommets dans une
composante d ej` a cr e ee. Pour cela, nous utilisons une structure de donn ees qui permet de g erer
une famille densembles, i.e., de v erier si deux el ements sont dans le m eme ensemble, et de
fusionner deux ensembles en un autre ensemble.
On va munir chaque composante dun (unique) repr esentant. On peut alors d eterminer si deux
sommets se trouvent dans la m eme composante en regardant sils ont le m eme repr esentant.
On stockera les el ements dune composante dans un arbre, dont la racine est un repr esentant.
Lop eration FIND cherche pour un sommet donn e la racine de son arbre. Lop eration UNION
forme lunion de deux arbres, en ajoutant larbre avec le plus petit nombre de sommets en tant
que descendant de la racine de larbre avec le plus grand nombre de sommets. (Choix arbitraire,
si les tailles sont les m emes.)
Co ut pour FIND: hauteur de larbre.
Co ut pour UNION: hauteur de larbre.
Th eor` eme 7.9 Soit T larbre obtenu en formant des unions el ement par el ement dans un ordre
arbitraire. Alors la hauteur de T est au plus egale ` a log
2
([T[).
Preuve. Nous proc edons par induction sur [T[ (le nombre de sommets dans T).
Base: Si [T[ = 1 alors sa hauteur vaut 0, et on a bien log
2
([T[) = log
2
(1) = 0.
Pas: Supposons que T est lunion de deux arbres T
1
et T
2
de hauteurs h
1
et h
2
. Remar-
quons quon a [T[ = [T
1
[ + [T
2
[, donc (en supposant que T
1
et T
2
ont au moins un sommet
chacun) [T
1
[, [T
2
[ < [T[. Nous pouvons donc appliquer lhypoth` ese dinduction pour obtenir
h
1
log
2
([T
1
[) et h
2
log
2
([T
2
[).
Supposons sans perte de g en eralit e que [T
1
[ [T
2
[, donc la racine de T
1
sera dans T un
descendant de la racine de T
2
(par la construction de T). Notons h la hauteur de T, alors h =
maxh
1
+ 1, h
2
. Nous distinguons deux cas.
Cas 1. h
1
< h
2
: alors h = h
2
log
2
([T
2
[) < log
2
([T[), par hypoth` ese dinduction, et
puisque [T
2
[ < [T[.
Cas 2. h
2
h
1
: h = h
1
+ 1 log
2
([T
1
[) + log
2
(2) = log
2
(2 [T
1
[) log
2
([T
1
[ + [T
2
[) =
log
2
([T[).
193
Donc on a dans tous les cas h log
2
([T[).
Lop eration FIND peut etre impl ement ee pour des composantes de graphes comme suit. Nous
maintenons pour chaque sommet v du graphe les champs suivants:
v.pred: pointeur au parent ou NULL si cest une racine.
v.size: la taille de la composante correspondante ` a v, si cest le repr esentant. (Sil ne sagit
pas du repr esentant, ce champ ne sera pas utilis e.)
Algorithme 56 FIND(u)
Input: Sommet u dun graphe
Output: le repr esentant de la composante de u.
1: r u
2: while r.pred ,= NULL do
3: r r.pred
4: end while
5: return r
Algorithme 57 UNION(u, v)
Input: Sommets u et v dun graphe.
Output: Fusionne les ensembles contenant u et v; retourne true ssi u et v etaient dans des
composantes distinctes.
1: r FIND(u)
2: s FIND(v)
3: if r ,= s then
4: if s.size r.size then
5: s.pred r
6: r.size r.size +s.size
7: else
8: r.pred s
9: s.size s.size +r.size
10: end if
11: return true
12: else
13: return false
14: end if
Exemple: Supposons que nous avons les composantes suivantes:
a, b, h, k, m, c, g, p, e, d, n,
avec comme repr esentants respectifs b, g, e et n. Ils pourraient donc etre stock es comme suit:
194
a
g
h
m
k
e
c
d
n
p
b
Donc par exemple FIND(k) retournerait b (la racine), FIND(g) retournerait g, FIND(e) re-
tournerait e, et FIND(d) retournerait n. Si nous appelons UNION(a, m), lalgorithme ne toucherait
pas aux arbres et retournerait FALSE (puisque a et m se trouvent dans la m eme composante). Par
contre si nous appelons UNION(h, p), lalgorithme retournerait TRUE et nous aurions:
m
h
a
g
k
p
c
b e
d
n
En effet, puisque la composante de p (3 sommets) est plus petite que celle de h (5 sommets),
sa racine g est ajout ee comme descendant de la racine de la composante de h (cest ` a dire b).
Nous avons donc fait lunion des deux composantes. Nos composantes sont donc maintenant:
a, b, c, g, h, k, m, p, e, d, n.
7.9.3 Version nale de lalgorithme de Kruskal
Nous commencons par mettre toutes les ar etes dans un heap, an de pouvoir rapidement
retrouver la moins ch` ere ` a chaque etape. Au fur et ` a mesure que nous choisissons quelles ar etes
prendre pour notre arbre couvrant minimal, nous les placons dans lensemble T. Nous regardons
les ar etes de la moins ch` ere ` a la plus ch` ere. Une ar ete est ajout ee ` a T si elle connecte deux
composantes connexes (si UNION(u, v) retourne TRUE), cest-` a-dire si elle ne cr ee pas de cycle.
On sait quun arbre sur n sommets doit avoir n 1 ar etes, donc d` es que [T[ = n 1 nous avons
notre arbre T.
7.9.4 Lalgorithme de Prim
Comme lalgorithme de Kruskal, lalgorithme de Prim trouve un arbre couvrant minimal dans
un graphe G. Il commence ` a un sommet et grandit ensuite larbre ar ete par ar ete.
195
Algorithme 58 MINSPANKRUSKAL(G, w)
Input: Graphe G = (V, E) muni dune fonction de poids w: E R
>0
Output: Ensemble E
dar etes qui forment un arbre couvrant minimal de G.

1: BOTTOMUPHEAPCREATE(E) (par rapport ` a w)
2: for v V do
3: v.pred NULL
4: v.size 1
5: end for
6: T
7: while Nombre dar etes dans T < n 1 do
8: (u, v) DELETEMIN(E)
9: b UNION(u, v)
10: if b = true then
11: T T (u, v)
12: end if
13: end while
14: return T
En tant qualgorithme glouton, quelle ar ete devrions nous prendre? Lar ete la moins ch` ere
qui ajoute un sommet ` a larbre sans cr eer de cycle.
Pendant lex ecution, nous indexons chaque sommet soit avec fringe (anglais pour bord)
sil existe une ar ete que le relie ` a larbre d ej` a cr e e, et avec unseen sinon.
1: Choisir un sommet arbitraire pour commencer, ajouter ses voisins ` a fringe.
2: while il y a des sommets fringe do
3: Choisir une ar ete e = (v, f), avec v appartenant ` a larbre et f ` a fringe.
4: Ajouter le sommet v et lar ete e ` a larbre.
5: Enlever f de fringe.
6: Ajouter tous les voisins unseen de f dans fringe.
7: end while
Cette proc edure cr ee clairement un arbre couvrant, puisquaucun cycle ne peut etre introduit
entre larbre et des sommets fringe. Mais sagit-il dun arbre minimal?
Th eor` eme 7.10 Soit G = (V, E) un graphe connexe et pond er e (avec poids). Soit E
T
E un
sous-ensemble dar etes tel que T = (V, E
T
) est un arbre couvrant minimal. Soit E
E
T
, et
soit V
V lensemble des sommets incidents ` a une ar ete dans E
. Si (x, y) est une ar ete de

poids minimal telle que x V
et y / V
, alors E
(x, y) est un sous-ensemble dun arbre

couvrant minimal.
Preuve. Nous pouvons supposer que (x, y) / E
T
. Comme T est un arbre couvrant, il y a
un chemin de x ` a y dans T. Soit (u, v) une ar ete sur ce chemin telle que u V
, v / V
.
196
En effacant (u, v) et en le remplacant par (x, y), on obtient un autre arbre couvrant. Comme
w(u, v) w(x, y), le co ut de cet arbre couvrant est inf erieur ou egal au co ut de T.
Quel est le temps de parcours de lalgorithme de Prim? Cela d epend des structures de donn ees
utilis ees.
Limpl ementation la plus simple: marquer chaque sommet comme appartenant ` a larbre ou
non, et recommencer la recherche ` a chaque fois d` es le d ebut:
1: Choisir un sommet arbitraire pour commencer.
2: while il y a des sommets non-arbre do
3: Choisir une ar ete minimale avec une extremit e dans larbre et lautre hors larbre.
4: Ajouter lar ete choisie et le sommet correspondant ` a larbre.
5: end while
On peut r ealiser ceci en temps O([V [ [E[) en utilisant DFS/BFS pour parcourir toutes les
ar etes avec un temps constant par ar ete et un total de n it erations, n = [V [. Peut-on faire mieux?
OUI.
Lalgorithme am elior e r esultant ressemble ` a lalgorithme de Dijkstra. Nous ajoutons ` a larbre
T un sommet (et une ar ete) ` a chaque etape. Nous stockons lensemble Q des sommets qui ne
sont pas encore dans T. Les sommets de T sont donc ceux de V Q. Pour chaque sommet v Q,
nous stockons une cl e, qui, ` a nimporte quel point de lalgorithme est la distance minimale de v ` a
larbre actuel T. A la n de lalgorithme, lensemble Q est vide, T contient tous les sommets du
graphe, et est un arbre minimal couvrant. Nous impl ementons Q sous forme de queue ` a priorit e
(heap) par rapport aux cl es (les plus petits el ements etant prioritaires).
Remarquons que nous repr esentons les ar etes de T avec larray p. Pour un sommet v, p[v]
est le pr ed ecesseur de v, donc (p[v], v) est une ar ete de T. Notons que T a bien n 1 ar etes
puisque tous les sommets sauf s ont un pr ed ecesseur.
Pour montrer que lalgorithme fonctionne correctement, nous devons montrer que key[v] est
toujours la distance de v ` a V Q u, o` u u est choisi ` a l etape 8. Cest une simple preuve par
induction.
Pourquoi avons-nous besoin de l etape 13 (SiftUp)? Nous utilisons Q comme min-heap.
Dans l etape 12, la valeur de key[v] a et e r eduite. Donc, v doit trouver sa juste place dans le
heap, et il faut donc faire un SiftUp (cest SiftUp plut ot que SiftDown, parce que larbre est un
min-heap, i.e. la racine contient le plus petit el ement).
Th eor` eme 7.11 Le temps de parcours de lalgorithme MINSPANPRIM est O(mlog(n)), o` u m =
[E[, n = [V [.
Preuve. La queue est cr e ee en temps O(n) dans l etape 6 (BOTTOMUPHEAPCREATE, par ex-
emple). Le cout d etapes 8 dans lalgorithme entier est O(mlog(m)): Chaque sommet v est
inserer dans Qau plus deg(v) fois, donc Qa au plus m = [E[ elements. La boucle for de la ligne
197
Algorithme 59 MINSPANPRIM(G, w)
>0
Output: Ensemble E
dar etes qui forment un arbre couvrant de G.

1: Choisir s V arbitrairement.
2: for u V s do
3: key[u]
4: end for
5: key[s] 0, p[s] NULL
6: Q queue de priorit e (min-heap) sur V p.r. ` a key
7: while Q nest pas vide do
8: u ExtractMin(Q)
9: if u est deja marqu e then
10: Goto Pas 7
11: end if
12: Marquer u
13: for v N[u] do
14: if v nest pas marqu e w(u, v) < key[v] then
15: p[v] u, key[v] w(u, v)
16: SiftUp(Q, v)
17: end if
18: end for
19: end while
20: E
(p[v], v) [ v V v ,= s.
198
13 est parcourue au plus 2m fois, comme chaque ar ete est visit ee au plus une fois pour chacun
des sommets incidents. Lop eration ` a la ligne 16 est effectu ee en temps O(log(m)), donc le co ut
total de cette op eration pendant lex ecution compl` ete de lalgorithme est O(mlog(m)). Toutes
les autres op erations utilisent un temps O(m). Ainsi, le temps de parcours complet est
O(mlog(m) +n) = O(mlog(n)),
parce que m n
2
, donc log(m) 2 log(n).
7.10 D
ETECTER DES CYCLES

Pendant la discussion de lalgorithme Moore-Bellman-Ford nous avions suppos e que le graphe
ne contenait pas de cycles n egatifs. Dans cette section nous verrons comment trouver de tels
cycles. De plus, nous etudierons le probl` eme de trouver un cycle avec le plus petit poids dar ete
moyen (lalgorithme de Karp).
7.10.1 Detecter des cycles negatifs
Lalgorithme suivant, dune simplicit e surprenante, d etermine si un graphe G = (V, E) muni
dune fonction de poids w: E R poss` ede un cycle n egatif.
Algorithme 60 NEGATIVECYCLE(G, w)
Output: true si G a un cycle n egatif, false sinon.
1: Choisir un s V arbitraire.
2: Appliquer lalgorithme de Moore-Bellman-Ford ` a (G, s), pour obtenir pour tout w V la
distance la plus courte (w) entre s et w.
3: for (u, v) E do
4: if (u) +w(u, v) < (v) then
5: return true
6: end if
7: end for
8: return false
Th eor` eme 7.12 Lalgorithme ci-dessus donne un r esultat correct en O(nm) op erations, o` u n =
[V [ et m = [E[.
Preuve. Pour le temps de parcours, nous savons quil faut O(nm) op erations pour lalgorithme
MBF, et voyons ensuite quil en faut O(m) pour la boucle for aux lignes 3-7 (puisque la boucle
est ex ecut ee une fois pour chaque ar ete).
199
Montrons maintenant que lalgorithme est correct. Sil existe une ar ete (u, v) telle que (u)+
w(u, v) < (v), alors (v) nest pas la longueur du plus court chemin de s ` a v, comme le chemin
passant par u est encore plus court. Donc G contient n ecessairement un cycle n egatif, puisque
nous savons que lalgorithme de Moore-Bellman-Ford marche sur tout graphe qui na pas de
cycles n egatifs. Supposons maintenant que lalgorithme termine avec loutput FALSE. Alors:
(u, v) E: [u] +w(u, v) [v].
Soit C = (v
0
, v
1
, . . . , v
k
) un cycle, i.e., (v
i
, v
i+1
) E pour tout i, et v
0
= v
k
. Nous aimerions
montrer que C est positif.
k
i=1
_
[v
i1
] +w(v
i1
, v
i
)
_
i=1
[v
i
].
Comme

k
i=1
[v
i1
] =
k
i=1
[v
i
] (v
0
= v
k
), on peut enlever ces deux termes de la somme
ci-dessus pour obtenir:
k
i=1
w(v
i1
, v
i
) 0.
Donc, le cycle C est positif. Ainsi le graphe ne peut pas contenir de cycles n egatifs.
7.10.2 Lalgorithme de Karp pour trouver des cycles avec poids
moyen minimal
Soit C = (v
0
, v
1
, . . . , v
k
) un cycle dans le graphe G (donc v
0
= v
k
). Nous supposons que G est
orient e et connexe. Alors la quantit e
(C) :=
1
k
k
i=1
w(v
i1
, v
i
)
est le poids moyen de C. D` es lors,
(G) = min
C cycle dans G
(C)
est le poids moyen minimal dun cycle du graphe. Karp a construit en 1978 un algorithme pour
calculer cette quantit e.
Soit s un sommet arbitraire dans G = (V, E). Pour x V soit
F
k
(x) := min
_
k
i=1
w(v
i1
, v
i
)
v
0
= s, v
k
= x, (v
i1
, v
i
) E
_
la longueur du plus court chemin de s ` a x utilisant exactement k ar etes. Pour tout x V ,
0 k < n, nous pouvons calculer les valeurs F
k
(x) en utilisant la programmation dynamique:
200
F
0
(s) = 0
x V s: F
0
(x) =
1 k n, x V :
F
k
(x) = min
uV (u,x)E
F
k1
(u) +w(u, x).
Exercice: Montrer que les r ecursions sont correctes et que les valeurs F
k
(x) peuvent etre cal-
cul ees en temps O(nm).
Th eor` eme 7.13 La quantit e
satisfait l egalit e suivante:
= min
xV
max
0k<n
F
n
(x) F
k
(x)
n k
.
Preuve. Nous consid erons dabord le th eor` eme dans le cas
= 0, i.e., nous montrons que dans

ce cas
min
xV
max
0k<n
F
n
(x) F
k
(x) = 0.
Soit (x) le co ut minimal dun chemin simple de s ` a x (i.e., un chemin qui ne passe pas deux fois
par le m eme sommet).
Un tel chemin passe par au plus n 1 ar etes (sinon il ne serait pas simple). De plus, comme
= 0, il ny a pas de cycles n egatifs, les chemins simples sont donc les plus courts et on a donc
x V : (x) = min
0k<n
F
k
(x) F
n
(x).
Ceci implique que
x V : max
0k<n
F
n
(x) F
k
(x) 0,
donc en particulier:
min
xV
max
0k<n
F
n
(x) F
k
(x) 0.
Pour nir la preuve, nous devons montrer quil y a un sommet x tel que F
n
(x) = (x). Soit C un
cycle dans le graphe avec (C) = 0, et soit w C arbitraire (nous savons quun tel cycle existe
puisque
= 0).
Soit P un chemin minimal de s ` a w suivi par n it erations du cycle C. P contient au moins n
ar etes. Soit P
le chemin form e par les premi` eres n ar etes de P. Le co ut du chemin P est (w)
(comme (C) = 0 et il ny a pas de cycles n egatifs). Tout sous-chemin dun chemin de co ut
minimal est aussi de co ut minimal. Si E
d enote les ar etes de P
, et x son sommet terminal, alors
eE
w(e) = (x) = F
n
(x).
201
Donc, x est un sommet avec (x) = F
n
(x), ce qui montre lafrmation du th eor` eme pour
= 0.
Dans le cas g en eral, en r eduisant les poids des ar etes dune constante t, on r eduit
min
xV
max
0k<n
F
n
(x) F
k
(x)
n k
par t. (Pourquoi?) Choisir alors t =
et appliquer la partie pr ec edente.

Th eor` eme 7.14 L algorithme de Karp calcule son output en temps O(nm).
Preuve. Les valeurs F
k
(x) pour x V peuvent etre calcul ees en temps O(nm). La m eme chose
est vraie pour les valeurs
F
n
(x) F
k
(x)
n k
.
Pour construire un cycle C avec (C) =
, on doit trouver k et x tel que

F
n
(x) F
k
(x)
n k
=
.
Ces valeurs peuvent etre calcul ees est stock ees pendant le calcul de
. Cette identit e dit que le

cycle qui nous int eresse est form e des n k derni` eres ar etes dun chemin minimal de s ` a x avec
n ar etes. Il est donc facile de reconstruire le cycle si pendant le calcul de F
k
(x) nous stockons
aussi le sommet pr ed ecesseur p
k
(x):
p
k
(x) := v avec F
k
(x) = F
k1
(x) +w(v, x).
Ceci conclut la preuve.
202
8
Les problèmes NP-complets
Nous avons jusqu` a pr esent surtout vu des probl` emes pour lesquels il existe une solution algo-
rithmique efcace, ce qui a peut- etre suscit e la fausse impression que tous les probl` emes ont de
telles solutions.
Ce nest pas vrai du tout! En fait, malgr e de nombreux efforts des meilleurs experts du
domaine, beaucoup de probl` emes qui semblent similaires ` a ceux vus dans ce cours restent sans
algorithme efcace.
La th eorie de NP-compl etude tente dexpliquer pourquoi nous navons pas r eussi ` a trouver
des bons algorithmes dans certains cas. Dans ce chapitre, nous verrons les aspects principaux de
cette th eorie.
8.1 LA CLASSE P
Une fonction f : N R est dite polynomiale en fonction de g : N R sil existe un polyn ome
p et un entier N tels que pour tout n N: f(n) p
_
g(n)
_
.
Exemples:
D ecider si un graphe G = (V, E) est connexe: la longueur dinput est polynomiale en n = [V [.
La longueur doutput est O(1).
Trouver le ux maximal dun r eseau (G, c, s, t), o` u les co uts sont des entiers positifs M: la
longueur dinput est polynomiale en [G[ et log
2
(M). La longueur doutput est aussi polyno-
miale en [G[ et log
2
(M).
D ecider si un entier N est premier: la longueur dinput est log
2
(N). La longueur doutput
est O(1).
Le probl` eme du sac ` a dos: Etant donn e n objets de poids W et des valeurs V , trouver
la plus grande somme de sous-ensemble (subset sum) qui est M: la longueur dinput est
polynomiale en n, log
2
(W), log
2
(V ), et log
2
(M); la longueur doutput est polynomiale en n
et log
2
(W).
203
On dit quun probl` eme est dans P ou est en temps polynomial sil existe un algorithme pour
le r esoudre dont le temps de parcours est polynomial en la longueur de linput.
Exemples:
D ecider si un graphe est connexe est dans P.
Trouver le ux maximal dun graphe est dans P.
Est-ce que le probl` eme du sac-` a-dos est dans P?
Est-ce que le probl` eme de d ecider la primalit e dun entier est dans P?
Il a et e r ecemment prouv e, apr` es des ann ees de recherche, voire des si ecles (depuis Gauss
en fait), que ce dernier probl` eme est dans P. En effet un algorithme (lalgorithme AKS, 2002)
r esout ce probl` eme en temps polynomial.
Le troisi` eme probl` eme nest tr` es probablement pas dans P: nous montrerons plus tard quil
est NP-complet.
La classe P couvre, en un certain sens, la classe des probl` emes que lon peut r esoudre de
mani` ere efcace, asymptotiquement.
8.2 R
EDUCTION POLYNOMIALE
But: Utiliser une solution dun probl` eme B pour r esoudre un probl` eme A.
Nous dirons que le probl` eme Aest polynomialement r eductible ` a un probl` eme B si nimporte
quel input a de A, peut etre transform e en temps polynomial en un input b de B tel que A est
solvable sur a si et seulement si B est solvable sur b. De plus, nous exigeons que la longueur de
b soit polynomiale en la longueur de a.
Nous notons ceci A
P
B. Cette relation entre probl` emes est en fait une relation transitive
: Si A
P
B et B
P
C, alors A
P
C. En effet, deux r eductions polynomiales forment une
r eduction polynomiale.
Exemple: Soit A le probl` eme maximum bipartite matching, et B le probl` eme du ux maximal.
Nous avons vu que A
P
B.
Si A
P
B, alors A est au plus aussi dur que B. Si A
P
B et B
P
A, nous ecrivons
A =
P
B. Dans ce cas, A et B sont ` a peu pr` es de m eme difcult e.
8.3 LA CLASSE NP
Pour de nombreux probl` emes, aucun algorithme en temps polynomial nest connu. Cependant,
pour de nombreux probl` emes de d ecision, on peut donner un algorithme qui v erie une solution
204
en temps polynomial.
Exemple: Consid erons le probl` eme de d ecision suivant: Etant donn e un entier n, est-t-il com-
pos e? (i.e. non-premier).
Supposons que nous ne sachions pas comment r esoudre ce probl` eme en temps polynomial
(ce qui etait encore le cas avant la decouverte de lalgorithme AKS en 2002). Il est par contre
facile de convaincre quelquun quun nombre n est compos e en exhibant deux entiers a > 1 et
b > 1 tels que a b = n. Ce test se fait en temps polynomial en log
2
(n), i.e. en la longueur de
linput.
La classe NP consiste en tous les probl` emes de d ecision pour lesquels il existe une preuve en
temps polynomial. Par exemple, le probl` eme ci-dessus de savoir si un nombre est compos e est
dans NP.
Tous les probl` emes dans P sont aussi dans NP. (Pourquoi?)
Nous donnons ` a pr esent une liste dautres probl` emes dans NP.
INDEPENDENTSET: etant donn e un graphe G = (V, E), et un entier K, le graphe contient-il
un ensemble ind ependant de taille K?
Rappelons quun ensemble independant dans un graphe G = (V, E) est un sous-ensemble I
de V tel que deux el ements quelconques de I ne sont pas reli es par une ar ete de V .
CLIQUE: etant donn e un graphe G = (V, E) et un entier K, le graphe contient-il une clique
de taille K?
Rappelons quune clique dans un graphe G = (V, E) est un sous-ensemble C de V tel que
deux el ements quelconque de C sont reli es par une ar ete de V .
Nous avons que
INDEPENDENT SET(G, K) =
P
CLIQUE(

G, K).
En effet, un ensemble ind ependant est une clique dans le compl ement du graphe.
205
Un node cover dans un graphe G = (V, E) est un sous-ensemble S V tel que chaque ar ete
a au moins un point terminal dans S. Le probl` eme NODE-COVER est comme suit: etant donn e
un entier K et le graphe G, existe-t-il un node cover dans G de taille K?
Remarquons que NODE-COVER =
P
INDEPENDENT-SET: Un sous-ensemble S de V est un
node cover si et seulement si I = V S est un ensemble ind ependant!
8.4 NP-COMPL
ETUDE
Un probl` eme A est appel e NP-complet si A NP et pour tous les probl` emes B dans NP on a
B
P
A.
Ainsi, si on peut r esoudre A en temps polynomial, alors on peut r esoudre tous les probl` emes
dans NP en temps polynomial! Donc, les probl` emes NP-complets peuvent etre consid er es
comme les probl` emes les plus difciles dans la classe NP. Nous avons le r esultat suivant:
Si A est NP-complet, B est dans NP, et A
P
B, alors B est aussi NP-complet.
La preuve est en fait triviale et sensuit des d enitions. Le premier probl` eme a avoir et e
identi e comme etant NP-complet est le satisability problem (SAT).
8.5 PROBL
`
EMES DE SATISFIABILIT
E
Consid erons les formules bool eennes suivantes:
Variables: x
1
, . . . , x
n
;
Litt eraux
i
: x
i
ou x
i
;
Clauses C
j
:
1

2

k
j
pour un certain k
j
> 0;
Formule F: C
1
C
2
C
t
pour un certain t > 0.
206
Exemple:
(x
1
x
2
x
3
x
4
) (x
1
x
2
) (x
1
x
2
x
4
).
Le prob` eme SAT est alors le suivant :
SAT: Etant donn e une formule F, peut-on donner aux variables des valeurs dans 0, 1 telles
que F soit vraie?
Th eor` eme 8.1. (Th eor` eme de Cook-Levin) SAT est NP-complet.
Le probl` eme k-SAT est une variante de SAT dans laquelle chaque clause doit consister en
exactement k litt eraux.
Th eor` eme 8.2. 3-SAT est NP-complet.
Preuve. Nous allons montrer que SAT
P
3-SAT. Etant donn e une formule F comme input pour
SAT, nous introduisons pour chaque clause
C
i
=
1

s
une nouvelle variable x
i
, et divisons C
i
en deux clauses:
F
i
= (
1

s2
x
i
) (
s1

s
x
i
).
Clairement, F
i
est satisfaisable si et seulement si C
i
est satisfaisable.
Nous proc edons r ecursivement en coupant la clause la plus grande jusqu` a ce que toutes les
clauses aient trois litt eraux. Si F contient une clause avec deux litt eraux
1
et
2
, nous ajoutons
une nouvelle variable X et divisons la clause en
(
1

2
x) (
1

2
x).
Ceci termine la preuve.
On peut montrer de la m eme facon: k-SAT est NP-complet pour k 3. Cependant: 2-SAT
est dans P! Cest-` a-dire, il existe un algorithme pour r esoudre 2-SAT en temps polynomial.
Not-all-equal-3-SAT (NAE-3-SAT): Toutes les clauses ont trois litt eraux. Une clause est
satisfaite si et seulement sil existe deux litt eraux dans la clause avec des valeurs diff erentes.
Par exemple:
(x, y, z) , (1, 0, 1), (0, 1, 0)
satisfait la clause
x y z.
Th eor` eme 8.3. NAE-3-SAT est NP-complet.
207
Preuve. Nous montrons que 3-SAT
P
NAE-SAT. Soit F = C
1
C
m
une formule dans
laquelle chaque clause contient exactement 3 litt eraux (donc F est un input pour le probl` eme 3-
SAT). Nous allons construire ` a partir de F une formule G de telle facon que F soit satisfaisable
si et seulement si G est NAE-satisfaisable.
Nous allons utiliser dans G les m emes variables x
1
, . . . , x
n
que dans F, en ajoutant en plus
m + 1 variables: w
1
, . . . , w
m
(donc un w
j
pour chaque clause C
j
), et une variable z. Ensuite
chaque clause
C
j
=
j1

j2

j3
dans F est transform ee en 2 nouvelles clauses:
C
1
j
..
(
j1

j2
w
j
)
C
2
j
..
(w
j

j3
z) .
dans G (G contient donc 2m clauses).
Si une attribution satisfait F, alors nous pouvons construire une attribution qui NAE-satisfait
G: Nous gardons les m emes valeurs pour x
1
, . . . , x
n
, puis nous posons z = 0, et j = 1, . . . , m :
w
j
=
j3

j1
. En effet:
Si
j3
= 1 alors C
2
j
est NAE-satisfaite (puisque z = 0), et comme w
j
,=
j1
, C
1
j
est aussi
NAE-satisfaite par notre attribution.
Si
j3
= 0 alors w
j
= 0, et donc w
j
= 1, ce qui implique que C
2
j
est NAE-satisfaite. De plus,
nous devons avoir
j1
= 1 ou
j2
= 1 (puisque
j3
= 0 et lattribution doit satisfaire C
j
) et donc
C
1
j
est aussi NAE-satisfaite.
R eciproquement, si une attribution NAE-satisfait G, alors nous allons montrer que cette
m eme attribution (restrainte aux variables x
1
, . . . , x
n
) satisfait aussi F. Supposons sans perdre
de g en eralit e que z = 0 (sinon nous prenons le compl ement de lattribution, qui NAE-satisfait
aussi G). Nous voyons que pour chaque clause C
j
:
Si
j3
= 1 alors C
j
est clairement satisfaite.
Si
j3
= 0 alors nous devons avoir w
j
= 1 (pour que C
2
j
soit NAE-satisfaite), et donc
w
j
= 0 ce qui implique que soit
j1
= 1 ou
j2
= 1 (puisque C
1
j
est NAE-satisfaite) et donc
C
j
=
j1

j2

j3
est aussi satisfaite.
Un autre probl` eme de satisabilit e NP-complet est
MAX-2-SAT: Etant donn e une formule dont toutes les clauses ont au plus deux litt eraux,
trouver une attribution des variables qui maximise le nombre de clauses satisfaites.
Exemple fondamental:
x y z w
(x y) (y z) (z x)
(x w) (y w) (z w).
Lemme 8.1. Si x y z = 1, alors il existe une attribution pour w qui satisfait sept des clauses
208
ci-dessus. Si x = y = z = 0, alors pour nimporte quelle valeur de w, la formule ci-dessus aura
au plus 6 clauses satisfaites.
Preuve. Exercice.
En utilisant cette construction, nous pouvons montrer que MAX-2-SAT est NP-complet.
Th eor` eme 8.4. MAX-2-SAT est NP-complet.
Preuve. Nous r eduisons 3-SAT ` a ce probl` eme. Etant donn e la formule 3-SAT C
1
C
m
,
nous introduisons pour chaque clause une nouvelle variable w
i
et remplacons la clause C
i
par les
10 clauses ci-dessus (avec w remplac e par w
i
et x, y et z remplac e par les lit eraux de C
i
).
La nouvelle formule a 10m clauses. Nous montrerons que la formule a 7m attributions
satisfaisantes si et seulement si la formule originale est satisfaisable. Dans chaque groupe de 10
nouvelles clauses, il peut y en avoir au plus 7 qui sont satisfaisantes. Ainsi, sil y en a 7m qui
sont satisfaites, le nombre de clauses satisfaites est exactement 7m, et par le lemme ci-dessus
toutes les clauses dans la formule 3-SAT originale sont satisfaites. Sil y a moins que 7m clauses
satisfaites, alors il y a un groupe qui a moins que 7 clauses satisfaites, et donc la formule originale
nest pas satisfaisable.
8.6 QUELQUES PROBL
`
EMES DE GRAPHE NP-COMPLETS
On rappelle dabord que INDEPENDENT-SET est le probl` eme suivant: Etant donn e un graphe G
et un nombre t N, d eterminer sil existe dans G un ensemble ind ependant de taille t
Th eor` eme 8.5. INDEPENDENT-SET est NP-complet.
Preuve. Nous allons montrer que 3-SAT
P
INDEPENDENT-SET. Etant donn e une formule
3-SAT avec t clauses, nous construisons un graphe qui a un ensemble ind ependant de taille t
si et seulement si la formule est satisfaisable. La construction de ce graphe se fait comme suit:
Chaque clause correspond ` a un triangle.
Les litt eraux compl ementaires sont reli es par une arr ete.
(x
1
x
2
x
3
) (x
1
x
2
x
3
) (x
1
x
2
x
3
)
x
1
x
2
x
2
x
3
x
3
x
1
x
1
x
2
x
3
209
Une attribution valable dans une formule 3-SAT avec t clauses donne un ensemble ind ependant
de taille t:
Nous commencons par mettre dans notre ensemble tous les sommets correspondant ` a des
litt eraux qui sont vrais dans lattribution. Dans chaque triangle, sil y a plus que deux sommets
dans notre lensemble, nous en enlevons un ou deux pour r eduire le nombre ` a un.
Lensemble r esultant est ind ependant: Un sommet dans un triangle ne peut pas etre connect e
a un sommet dans un autre triangle, puisque le litt eral et son compl ement ne peuvent pas tous
les deux valoir un. Deux sommets dans lensemble ind ependant ne peuvent pas etre dans un
triangle, puisque le proc ed e sen est assur e.
De plus, comme toutes les clauses sont vraies, il y a au moins un litt eral par clause qui est
vrai, et donc un moins un sommet par triangle qui est dans notre ensemble. Comme il y a t
triangles, la taille de lensemble est t.
Un ensemble ind ependant de taille t dans le graphe m` ene ` a une attribution valable de la
formule originale:
Clairement, si la formule originale a t clauses, alors le graphe a t triangles, et lensemble
ind ependant maximal est donc de taille t. Nous donnons ` a chaque litt eral dans lensemble
ind ependant la valeur 1, et aux autres litt eraux la valeur 0.
Alors chaque clause dans la formule est satisfaisable, et il ny a pas de contradiction entre
les litt eraux et leurs compl ements puisquils sont connect es dans le graphe (donc les deux ne
peuvent pas etre dans lensemble ind ependant).
Corollaire 8.1. CLIQUE et NODE-COVER sont NP-complets.
Cest parce que
INDEPENDENT-SET =
P
CLIQUE =
P
NODE-COVER.
Un cut dans un graphe G = (V, E) est une paire (S, V S), o` u S V . La taille dun cut est
le nombre darr etes entre S et V S.
MAX-CUT: Etant donn e un graphe G et un entier n, existe-t-il un cut de taille n?
Th eor` eme 8.6. MAX-CUT est NP-complet.
Preuve. Nous allons montrer que NAE-3-SAT
P
MAX-CUT. Etant donn e une formule NAE-
3-SAT F, nous construisons un graphe Get une valeur K tels que F est NAE-3-satisfaisable ssi
G a un cut de taille K. Soit m le nombre de clauses dans F, et soient x
1
, . . . , x
n
les variables.
On commence par poser K = 5m. Ensuite, notre graphe G a comme sommets x
1
, . . . , x
n
,
x
1
, . . . , x
n
. Pour chaque clause C
i
= , on ajoute le triangle [, , ] aux ar etes de
G. Pour chaque i, soit n
i
nombre doccurrences de x
i
ou x
i
dans F. Ajouter n
i
ar etes entre x
i
et x
i
dans G. G devient un graphe avec plusieurs ar etes entre ses sommets (un tel graphe est
appel e un multigraphe). Remarquons que G a 2n sommets, et 6m ar etes.
210
Supposons quil y a un cut (S, V S) de taille 5m dans G. Sans perte de g en eralit e, les
variables et leurs n egations ont des c ot es diff erents dun cut. Autrement, si x
i
et x
i
se trouvent
du m eme c ot e, ils contribuent ensemble au plus n
i
ar etes au cut. Si on les met de deux c ot es
diff erents, on augment la valeur du cut par n
i
(grace a lar ete entre x
i
et sa negation), et au m eme
temps, on diminu la valeur par au plus n
i
: on pert la valeur 1 pour chaque occurrences de x
i
dans
un clause. Alors, mettre x
i
et x
i
a deux c ot es differents diminu pas la valeur du cut.
Nous consid erons les litt eraux de S comme vrai et ceux dans V S comme faux.
Les ar etes entre des variables et leurs n egations contribuent au plus 3m au cut (autant quil
y a doccurrences de litt eraux). Les 2m ar etes restantes doivent venir des triangles. Un triangle
contribue soit 0 (si les 3 sommets sont du m eme cot e) soit 2 (sil y a 2 sommets dun cot e et un
de lautre) au cut. Comme il y a mtriangles qui doivent contribuer au moins 2m, chaque triangle
doit contribuer 2 au cut, et donc dans chaque triangle il y a 2 sommets dun cot e du cut et un de
lautre). Ainsi, dans chaque triangle, au moins un lit eral est vrai et un est faux, i.e., la formule
originale est NAE-satisfaisable.
Inversement, il est facile de traduire lattribution de v erit e qui satisfait toutes les clauses dun
cut de taille 5m.
Remarquons que le probl` eme de minimiser le cut est dans P! Donc, les probl` emes de minimi-
sation et de maximisation sont compl` etement diff erents.
8.7 QUELQUES AUTRES PROBLEMES DE GRAPHE
NP-COMPLETS
Un cycle Hamiltonien dans un graphe G = (V, E) est un chemin (v
0
, v
1
, . . . , v
n
) tel que v
n
= v
0
et tel que V = v
0
, . . . , v
n1
. Le probl` eme HAMILTONIAN-CYCLE demande si un graphe
donn e poss` ede un cycle Hamiltonien.
Th eor` eme 8.7. HAMILTONIAN-CYCLE est NP-complet.
Preuve. Nous ne la verrons pas ici. Il y a une preuve qui proc` ede en montrant que 3-SAT
P
HAMILTONIAN-CYCLE.
Notons que le probl` eme HAMILTONIAN-PATH, qui demande sil existe un chemin Hamil-
tonien dans un graphe donn e (i.e. la condition v
n
= v
0
est relax ee) est aussi NP-complet.
Voyons maintenant le probl` eme du Voyageur de Commerce (Travelling Salesman Problem)
TSP. Etant donn e n villes 1, . . . , n, des distances enti` eres et non n egatives d
ij
entre chaque paire
de villes telles que d
ij
= d
ji
et une borne enti` ere B. On se demande sil y a un tour des villes tel
que la distance totale parcourue est inf erieure ` a B. En dautres mots, existe-t-il une permutation
telle que
n1
i=1
d
(i),(i+1)
+d
(n),(1)
B.
Th eor` eme 8.8. TSP est NP-complet.
Preuve. Nous montrons que HAMILTONIAN-CYCLE
P
TSP. Pour un graphe donn e G avec n
211
sommets, nous construisons la matrice des distances d
ij
et un budget B tel que G a un chemin
Hamiltonien si et seulement sil existe un tour de longueur B.
Il y a n villes correspondant aux n sommets du graphe et
d
ij
=
_
1 si (i, j) E,
n + 1 sinon.
De plus, B = n + 1. Clairement, sil y a un tour de longueur B, alors le tour doit utiliser les
ar etes dans le graphe et doit visiter chaque ville une fois, donc cest un parcours Hamiltonien.
R eciproquement, un chemin Hamiltonien dans le graphe m` enera ` a un tour de co ut B.
Supposons que nous devons colorier les sommets dun graphe donn e avec k couleurs de
telle facon quil ny ait pas deux sommets adjacents de m eme couleur. Ce probl` eme sappelle le
probl` eme de k-coloriage (k-coloring). Pour k = 2, ce probl` eme est assez facile ` a r esoudre. Pour
k = 3, cest diff erent.
Th eor` eme 8.9. 3-COLORING est NP-complet.
Preuve. Nous ne la verrons pas ici. On peut utiliser une r eduction de NAE-SAT.
Il y a de nombreux autres probl` emes de th eorie des graphes qui sont NP-complets. Pour en
savoir plus sur les probl` emes NP-complets en g en eral:
M.R. Garey and D.S. Johnson, Computers and Interactibility: A Guide to the Theory of
NP-Completeness, Freeman Publishers, 1979.
C.H. Papadimitriou, Computational Complexity, Addison-Wesley, 1994
8.8 PROBL
`
EMES DE TH
EORIE DES ENSEMBLES

Etant donn e des ensembles nis B, G, H (garcons, lles, maisons), chacun contenant n el ements,
et un ensemble X B G H, le probl` eme TRIPARTITE MATCHING demande sil y a un
sous-ensemble M X de taille n tel que (b
1
, g
1
, h
1
), (b
2
, g
2
, h
2
) M = b
1
,= b
2
, h
1
,= h
2
et h
1
,= h
2
. Cest-` a-dire, chaque garcon est connect e ` a une lle diff erente, et chaque couple
poss` ede sa propre maison.
Th eor` eme 8.10. TRIPARTITE MATCHING est NP-complet.
Preuve. Nous ne la verrons pas ici.
Le probl` eme EXACT COVER BY 3-SETS: Etant donn e une famille F = S
1
, . . . , S
n
de
sous-ensembles dun ensemble U telle que [U[ = 3mpour un entier m, et telle que [S
i
[ = 3 pour
tout i, existe-t-il m ensembles dans F dont lunion est egale ` a U.
Th eor` eme 8.11. EXACT COVER BY 3-SETS est NP-complet.
212
Preuve. TRIPARTITE MATCHING est un cas sp ecial de EXACT COVER BY 3-SETS: dans ce cas,
lensemble U est partitionn e en trois ensembles egaux B, G, H tels que chaque ensemble dans
F contient un el ement de chacun des trois.
Rappelons le probl` eme du sac-` a-dos KNAPSACK: Etant donn e n el ements de valeurs pos-
itives enti` eres v
i
, des poids positifs w
i
, une limite W, et une valeur T enti` ere. Nous voulons
savoir sil y a un sous-ensemble S 1, . . . , n tel que
iS
w
i
W
and

iS
v
i
T.
Chapitre 4: Solution de programmation dynamique en temps O(nW). Or, ce temps de par-
cours nest pas polynomial en la longueur de linput O(nlog(W)). Existe-t-il un algorithme en
temps polynomial pour KNAPSACK? Cest peu probable.
Th eor` eme 8.12. KNAPSACK est NP-complet.
Preuve. Nous montrons que
EXACT COVER BY 3-SETS
P
KNAPSACK.
Soit S
1
, . . . , S
n
et U = 0, . . . , 3m 1 un input pour EXACT COVER BY 3-SETS. Nous
voulons le transformer en un input de KNAPSACK
Soit
w
i
= v
i
=
jS
i
(n + 1)
j
et
W = T =
3m1
j=0
(n + 1)
j
.
Noter que pour chaque I 1, . . . , n on a
iI
w
i
=
3m1
i=0
(n + 1)
j
j
,
o u
j
= [i I [ j S
i
[. On peut voir que il y a un sous ensemble I de 1, . . . , n telle que
iI
w
i
W et
iI
v
i
T si et seulement si
iI
w
i
= W (parce que w
i
= v
i
et W = V .)
On en d eduit que pour chaque j U, il y a exactement un i I telle que j S
i
; a montre que
[I[ = m, et que en plus
iI
S
i
= U.
213

Algo Polycopie2011

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Algo Polycopie2011

Hochgeladen von

Copyright:

Verfügbare Formate

Algorithmique

EORIE DES ENSEMBLES

) AB sont egaux si et seulement si a = a

contient, entre autres, les mots

dans lexemple ci-dessus) est la relation sup erieur ou

est une fonction. La relation

est la fonction racine carr ee.

ECIFICATION DUN PROBL

(N) est lensemble des sous-ensembles nis de N, et N

Remarque: Il nest pas n ecessaire de commencer linduction avec n = 1. En utilisant la m eme

Exemple: Moyenne arithm etique et moyenne g eom etrique (AGM):

S diff` erent en au moins deux positions.

V , o` u V est un ensemble ind ependant. Il en va de m eme pour (y, 1) et (y

Voici quelques exemples densembles ind ependants du n-hypercube pour n = 1, 2, 3, 4:

Etape 1: Nous montrons que pour tout k 1,

Etape 2: nous montrons quil existe , , R

= k, et donc avec l etape 1 on obtient lestimation suivante:

Etape 3: Preuve du th eor` eme.

Etant donn e n, nous trouvons k tel que a

Ecrivons S un ensemble dynamique, x un objet ( el ement) que S peut stocker, et k la cl e

EES POUR DES ALGORITHMES

pour nimporte quel sommet r

sont appel es des syn-

, alors les bits les moins signiants de

j pour un certain et un certain j petit.

de k (i.e. une cl e avec h(k) = h(k

)), nous aurons alors une

) est d ej` a occup ee et la nouvelle cl e doit donc etre stock ee autre

(ligne 5): Nous savons que c

Etant donn e un carr e de taille 2

5)/2. En fait, on peut d emontrer par r ecurrence que

5)/2 < 1, le r esultat C

travers ee il faut inclure l el ement correspondant dans notre LCS.

nous ajoutons A ` a notre suite (x

sont dans la m eme

sont incomparables (Pourquoi?). Donc

1 serait une solution pour S avec plus d el ements que A, ce qui

EMENTS DUNE STRAT

= A 1 est une solution optimale

nest pas marqu e then

nest pas marqu e. On a alors 0 < k. Le sommet v

V qui est marqu e mais

le premier sommet ` a etre marqu e avec cette propri et e.

N[v] pour un certain sommet marqu e v. Puisque v

etait le premier sommet non

, v est atteignable depuis s. Mais alors v

nest pas marqu e then

nest pas marqu e then

Remarquons quon peut choisir un cut et un ux quelconque dans le lemme pr ec edent. En

, s, t) de f. Les ar etes du graphe

:= e [ e E f(e) < c(e)

E, alors f(e) est augment e de , si e

e, alors f(e) est diminu e de

dar etes qui forment un arbre couvrant minimal de G.

qui ne cr ee pas de cycle lorsquelle est ajout ee

, alors il existe un arbre couvrant minimal T

= T et la proposition est v eri ee. Supposons

(puisque le fait dajouter e ` a E

naurait pas cr e e de cycle, et donc puisque e est la

dar etes qui forment un arbre couvrant minimal de G.

V lensemble des sommets incidents ` a une ar ete dans E

. Si (x, y) est une ar ete de

(x, y) est un sous-ensemble dun arbre

dar etes qui forment un arbre couvrant de G.