Algorithmique PDF

Algorithmique avance
IUP 2
Frdric Vivien
24 avril 2002
Table des matires

1
Introduction
1.1 Quest-ce que lalgorithmique ? .
1.2 Motivation : calcul de xn . . . .
1.2.1 Problme . . . . . . . .
1.2.2 Algorithme trivial . . . .
1.2.3 Mthode binaire . . . .
1.2.4 Algorithme des facteurs
1.2.5 Algorithme de larbre . .
1.2.6 Et aprs ? . . . . . . . .
1.3 Conclusion . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
9
9
9
9
10
10
11
12
12
12
Complexit et optimalit ; premier algorithme de tri

2.1 Dfinition de la complexit . . . . . . . . . . . .
2.1.1 Notations de Landau . . . . . . . . . . .
2.1.2 Complexit . . . . . . . . . . . . . . . .
2.1.3 Modle de machine . . . . . . . . . . . .
2.2 Illustration : cas du tri par insertion . . . . . . . .
2.2.1 Problmatique du tri . . . . . . . . . . .
2.2.2 Principe du tri par insertion . . . . . . . .
2.2.3 Algorithme . . . . . . . . . . . . . . . .
2.2.4 Exemple . . . . . . . . . . . . . . . . .
2.2.5 Complexit . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
13
13
13
13
14
14
14
14
14
14
15
La rcursivit et le paradigme diviser pour rgner

3.1 Rcursivit . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.1 Dfinition . . . . . . . . . . . . . . . . . . . . . .
3.1.2 Rcursivit simple . . . . . . . . . . . . . . . . .
3.1.3 Rcursivit multiple . . . . . . . . . . . . . . . .
3.1.4 Rcursivit mutuelle . . . . . . . . . . . . . . . .
3.1.5 Rcursivit imbrique . . . . . . . . . . . . . . .
3.1.6 Principe et dangers de la rcursivit . . . . . . . .
3.1.7 Non dcidabilit de la terminaison . . . . . . . . .
3.1.8 Importance de lordre des appels rcursifs . . . . .
3.1.9 Exemple dalgorithme rcursif : les tours de Hano
3.2 Drcursivation . . . . . . . . . . . . . . . . . . . . . . .
3.2.1 Rcursivit terminale . . . . . . . . . . . . . . . .
3.2.2 Rcursivit non terminale . . . . . . . . . . . . .
3.2.3 Remarques . . . . . . . . . . . . . . . . . . . . .
3.3 Diviser pour rgner . . . . . . . . . . . . . . . . . . . . .
3.3.1 Principe . . . . . . . . . . . . . . . . . . . . . . .
3.3.2 Premier exemple : multiplication nave de matrices
3.3.3 Analyse des algorithmes diviser pour rgner . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
17
17
17
17
17
18
18
18
19
19
20
21
21
22
23
23
23
24
24
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
TABLE DES MATIRES

3.3.4
3.3.5
Rsolution des rcurrences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Deuxime exemple : algorithme de Strassen pour la multiplication de matrices . . . . . . . .
Algorithmes de tri
4.1 Tri par fusion . . . . . . . . . . . . . . .
4.1.1 Principe . . . . . . . . . . . . . .
4.1.2 Algorithme . . . . . . . . . . . .
4.1.3 Complexit . . . . . . . . . . . .
4.2 Tri par tas . . . . . . . . . . . . . . . . .
4.2.1 Dfinition dun tas . . . . . . . .
4.2.2 Conservation de la structure de tas
4.2.3 Construction dun tas . . . . . . .
4.2.4 Algorithme du tri par tas . . . . .
4.3 Tri rapide (Quicksort) . . . . . . . . . . .
4.3.1 Principe . . . . . . . . . . . . . .
4.3.2 Algorithme . . . . . . . . . . . .
4.3.3 Complexit . . . . . . . . . . . .
25
25
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
29
29
29
29
30
31
31
31
32
33
33
33
36
37
Structures de donnes lmentaires

5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . .
5.2 Piles et files . . . . . . . . . . . . . . . . . . . . . . . .
5.2.1 Piles . . . . . . . . . . . . . . . . . . . . . . . .
5.2.2 Files . . . . . . . . . . . . . . . . . . . . . . . .
5.3 Listes chanes . . . . . . . . . . . . . . . . . . . . . .
5.3.1 Dfinitions . . . . . . . . . . . . . . . . . . . .
5.3.2 Algorithmes de manipulation des listes chanes
5.3.3 Comparaison entre tableaux et listes chanes . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
39
39
39
39
40
42
42
43
44
Programmation dynamique
6.1 Multiplication dune suite de matrices .
6.2 lments de programmation dynamique
6.2.1 Sous-structure optimale . . . .
6.2.2 Sous-problmes superposs . .
6.2.3 Recensement . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
47
47
51
51
51
51
.
.
.
.
.
.
.
53
53
54
54
54
55
55
55
.
.
.
.
.
57
57
58
60
60
61
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Algorithmes gloutons
7.1 Location dune voiture . . . . . . . . . . . . . . . . .
7.2 lments de la stratgie gloutonne . . . . . . . . . . .
7.2.1 Proprit du choix glouton . . . . . . . . . . .
7.2.2 Sous-structure optimale . . . . . . . . . . . .
7.3 Fondements thoriques des mthodes gloutonnes . . .
7.3.1 Matrodes . . . . . . . . . . . . . . . . . . . .
7.3.2 Algorithmes gloutons sur un matrode pondr
Graphes et arbres
8.1 Graphes . . . . . . . . . . .
8.2 Arbres . . . . . . . . . . . .
8.3 Parcours . . . . . . . . . . .
8.3.1 Parcours des arbres .
8.3.2 Parcours des graphes
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
TABLE DES MATIRES

9
Arbres de recherche et arbres de recherche quilibrs

9.1 Arbres binaires de recherche . . . . . . . . . . . .
9.1.1 Dfinition . . . . . . . . . . . . . . . . . .
9.1.2 Recherches . . . . . . . . . . . . . . . . .
9.1.3 Insertion dun lment . . . . . . . . . . .
9.1.4 Suppression dun lment . . . . . . . . .
9.1.5 Complexit . . . . . . . . . . . . . . . . .
9.2 Arbres rouge et noir . . . . . . . . . . . . . . . . .
9.2.1 Dfinition . . . . . . . . . . . . . . . . . .
9.2.2 Rotations . . . . . . . . . . . . . . . . . .
9.2.3 Insertion . . . . . . . . . . . . . . . . . .
9.2.4 Suppression . . . . . . . . . . . . . . . . .
9.2.5 Complexit . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
63
63
63
63
64
64
66
66
66
67
67
67
69
10 Plus courts chemins

10.1 Plus courts chemins origine unique . . . . . . .
10.1.1 Algorithme de Dijkstra . . . . . . . . . .
10.1.2 Algorithme de Bellman-Ford . . . . . . .
10.2 Plus courts chemins pour tout couple de sommets
10.2.1 Programmation dynamique nave . . . .
10.2.2 Algorithme de Floyd-Warshall . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
75
75
75
76
78
79
79
11 NP-compltude
11.1 La classe P . . . . . . . . . . . . . . . . . .
11.1.1 Problmes abstraits . . . . . . . . . .
11.1.2 Codage . . . . . . . . . . . . . . . .
11.2 La classe NP . . . . . . . . . . . . . . . . .
11.2.1 Algorithme de validation . . . . . . .
11.2.2 La classe de complexit NP . . . . .
11.3 NP-compltude . . . . . . . . . . . . . . . .
11.3.1 Rductibilit . . . . . . . . . . . . .
11.3.2 Dfinition de la NP-compltude . . .
11.3.3 Exemples de problmes NP-complets
11.3.4 Preuves de NP-compltude . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
83
83
83
84
84
84
85
85
85
86
86
87
12 Heuristiques
12.1 Le problme de la couverture de sommet
12.1.1 Heuristique . . . . . . . . . . .
12.1.2 Exemple dutilisation . . . . . .
12.1.3 Garantie de performances . . .
12.2 Le problme du voyageur de commerce
12.2.1 Exemple dutilisation . . . . . .
12.2.2 Garantie de performances . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
89
89
90
90
90
91
91
91
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Table des figures

1.1
1.2
Arbre de puissances. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Schma de calcul pour n = 23. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12
12
2.1
Exemple dutilisation de lalgorithme T RI -I NSERTION. . . . . . . . . . . . . . . . . . . . . . . . . .
15
3.1
3.2
Mthode de rsolution du jeu des tours de Hano. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Exemple dexcution de lalgorithme drcursiv. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
20
23
4.1
4.2
4.3
4.4
4.5
4.6
4.7
4.8
Algorithme F USIONNER. . . . . . . . . . . . . . . . . . .
Algorithme T RI -F USION . . . . . . . . . . . . . . . . . .
Exemple de tas. . . . . . . . . . . . . . . . . . . . . . . .
Algorithme E NTASSER . . . . . . . . . . . . . . . . . . .
Exemple dutilisation de lalgorithme E NTASSER. . . . . .
Algorithme C ONSTRUIRE -TAS. . . . . . . . . . . . . . .
Exemple dutilisation de lalgorithme C ONSTRUIRE -TAS.
Exemple dutilisation de lalgorithme T RIER -TAS. . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
30
30
31
32
32
33
34
35
5.1
5.2
5.3
5.4
5.5
5.6
5.7
5.8
5.9
Exemple de manipulation de pile. . . . . . . . . . . . . . . . . . . .

Implmentation dune pile par un tableau. . . . . . . . . . . . . . . .
Algorithmes de manipulation des piles implmentes par des tableaux.
Exemple de manipulation de file. . . . . . . . . . . . . . . . . . . . .
Implmentation dune file par un tableau. . . . . . . . . . . . . . . .
Algorithmes de manipulation des files implmentes par des tableaux.
Exemple de manipulation de liste chane. . . . . . . . . . . . . . . .
Exemple de manipulation de liste doublement chane. . . . . . . . .
Efficacits respectives des listes chanes et des tableaux. . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
40
40
41
41
41
42
42
43
45
6.1
Illutration de lalgorithme O RDONNER -C HANE D E M ATRICES. . . . . . . . . . . . . . . . . . . . .
50
8.1
8.2
8.3
8.4
8.5
8.6
8.7
8.8
8.9
8.10
8.11
8.12
8.13
Exemple de graphe orient. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Exemple de graphe non orient. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Exemple de graphe contenant un cycle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Exemple de fort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Exemple darbre. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Exemple darbres qui ne diffrent que sils sont enracins. . . . . . . . . . . . . . . . . . . .
Exemple darbres (enracins) qui ne diffrent que sils sont ordonns. . . . . . . . . . . . . .
Exemple darbres ordonns qui ne diffrent que quand ils sont vus comme des arbres binaires.
Algorithme de parcours en profondeur dun arbre. . . . . . . . . . . . . . . . . . . . . . . . .
Parcours prfixe, infixe et postfixe dun arbre. . . . . . . . . . . . . . . . . . . . . . . . . . .
Algorithme de parcours en largeur dun arbre. . . . . . . . . . . . . . . . . . . . . . . . . . .
Algorithme de parcours en profondeur dun graphe. . . . . . . . . . . . . . . . . . . . . . . .
Algorithme de parcours en largeur dun graphe. . . . . . . . . . . . . . . . . . . . . . . . . .
57
57
58
58
58
59
59
60
60
60
61
61
61
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
TABLE DES FIGURES

9.1
9.2
9.3
9.4
9.5
9.6
9.7
9.8
9.9
9.10
9.11
9.12
9.13
9.14
9.15
Deux arbres binaires de recherche contenant les mmes valeurs. . . . . . . . . . . . . . . .

Localisation du successeur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Algorithme dinsertion dans un arbre binaire de recherche. . . . . . . . . . . . . . . . . . .
Cas de figure lors de la suppression dun nud dun arbre binaire de recherche. . . . . . . .
Suppression dun lment dans un arbre binaire de recherche. . . . . . . . . . . . . . . . . .
Exemple darbre rouge et noir. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rotations sur un arbre binaire de recherche. . . . . . . . . . . . . . . . . . . . . . . . . . .
Algorithme de rotation gauche pour un arbre binaire. . . . . . . . . . . . . . . . . . . . . .
Premire srie de configurations pathologiques pour linsertion dans un arbre rouge et noir. .
Deuxime srie de configurations pathologiques pour linsertion dans un arbre rouge et noir.
Algorithme dinsertion dans un arbre rouge et noir. . . . . . . . . . . . . . . . . . . . . . .
Exemple dinsertion dans un arbre rouge et noir. . . . . . . . . . . . . . . . . . . . . . . . .
Configurations pathologiques pour la suppression dans un arbre rouge et noir. . . . . . . . .
Suppression dun lment dans un arbre rouge et noir. . . . . . . . . . . . . . . . . . . . . .
Correction dun arbre rouge et noir aprs suppression dun lment. . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
63
64
65
65
66
67
67
68
68
69
70
71
72
73
74
10.1
10.2
10.3
10.4
10.5
10.6
10.7
10.8
Algorithme de Dijkstra pour le calcul des plus courts chemins. . . . . . . . . . . . . .

Exemple dexcution de lalgorithme de Dijkstra. . . . . . . . . . . . . . . . . . . . .
Algorithme de Bellman-Ford pour le calcul des plus courts chemins. . . . . . . . . . .
Exemple dexcution de lalgorithme de Bellman-Ford. . . . . . . . . . . . . . . . . .
Algorithme naf par programmation dynamique pour le calcul des plus courts chemins.
Un graphe orient et la squence des matrices calcules par P LUS -C OURTS -C HEMINS.
Algorithme de Floyd-Warshall pour le calcul des plus courts chemins. . . . . . . . . .
Exemple dexcution de lalgorithme de Floyd-Warshall. . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
76
77
77
78
80
80
81
82
12.1 Exemple dutilisation de lalgorithme C OUVERTURE -S OMMET-A PPROCHE. . . . . . . . . . . . . .

12.2 Exemple dutilisation de lalgorithme T OURNE -A PPROCHE. . . . . . . . . . . . . . . . . . . . . .
90
92
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Avertissement
Ce cours ne traite pas :
la recherche de motifs dans une chane de caractres (problme suppos tre abondamment trait dans le cours
de Programmation Oriente Objet) ;
lalgorithmique gomtrique (suppose tre traite dans les cours lis au traitement dimage).
Chapitre 1
Introduction
1.1 Quest-ce que lalgorithmique ?
Dfinition 1 (Algorithme). Un algorithme est suite finie doprations lmentaires constituant un schma de calcul
ou de rsolution dun problme.
Historique : Le mot algorithme provient de la forme latine (Algorismus) du nom du mathmaticien arabe AL
I auteur entre autres mais ce n est pas le plus important dun manuel de vulgaK HAREZMI ou AL -K HW ARIZM
risation sur le calcul dcimal positionnel indien (v. 830) expliquant son utilisation et, surtout, la manipulation des
diffrents algorithmes permettant de raliser les oprations arithmtiques classiques (addition, soustraction, multiplication, division, extraction de racines carres, rgle de trois, etc.).
Double problmatique de lalgorithmique
1. Trouver une mthode de rsolution (exacte ou approche) du problme.
Soient trois nombres rels a, b et c, quelles sont les solutions de lquation ax2 + bx + c ? (Rsultat bien
connu.)
Soient cinq nombres rels a, b, c, d et e, quelles sont les solutions de lquation ax5 +bx4 +cx3 +dx2 +ex+ f ?
(Pas de mthode gnrale, cf. la thorie de G ALOIS.)
2. Trouver une mthode efficace.
Savoir rsoudre un problme est une chose, le rsoudre efficacement en est une autre, comme nous allons le voir
la section 1.2.
Diffrences entre algorithmes et programmes

Un programme est la ralisation (limplmentation) dun algorithme au moyen dun langage donn (sur une
architecture donne). Il sagit de la mise en uvre du principe. Par exemple, lors de la programmation on soccupera
parfois explicitement de la gestion de la mmoire (allocation dynamique en C) qui est un problme dimplmentation
ignor au niveau algorithmique.
1.2
Motivation : calcul de xn
1.2.1 Problme
Donnes : un entier naturel n et un rel x. On veut calculer xn .
Moyens : Nous partons de y1 = x. Nous allons construire une suite de valeurs y1 , ..., ym telle que la valeur yk soit
obtenue par multiplication de deux puissances de x prcdemment calcules : yk = yu yv , avec 1 u, v < k,
k [2, m].
9
10
CHAPITRE 1. INTRODUCTION
But : ym = xn . Le cot de lalgorithme sera alors de m 1, le nombre de multiplications faites pour obtenir le rsultat
recherch.
1.2.2
Algorithme trivial
yi = yi1 y1 , i [2, n]. Rsultat : yn = xn . Cot : m 1 = n 1 multiplications.

Algorithme
y[1] = x
Pour i 2 n faire
y[i] = y[i 1] y[1]
renvoyer y[n]
1.2.3
Mthode binaire
Algorithme
1. crire n sous forme binaire
2. Remplacer chaque :
1 par la paire de lettres SX ;
0 par la lettre S .
3. liminer la paire SX la plus gauche.
4. Rsultat : un mode de calcul de xn o
S signifie lever au carr (squaring) ;
X signifie multiplier par x .
Le tout en partant de x.
Illustration avec n = 23
1. n = 10111
1 0 1
2.
SX S
SX SX SX
3.
SX SX SX
4. Nous partons de x et nous obtenons successivement :

x2 , x4 , x5 , x10 , x11 , x22 , x23 .
Nous sommes donc capables de calculer x23 en 7 multiplications au lieu de 22 !
Explication de la mthode
i=p
criture binaire de n : n = i=0 ai 2i .

Plaons nous au cours du calcul de puissances de x. Soit j le dernier bit de la reprsentation binaire de n qui ait
t dcod et soit y j le dernier rsultat obtenu. Initialement, j = p et y p = x = xa p .
Deux cas sont possibles pour a j1 :
1. a j1 = 1. a j1 est remplac par SX, nous levons y j au carr puis multiplions le rsultat par x. Le nouveau
rsultat est y j1 = y2j x.
2. a j1 = 0. a j1 est remplac par S et nous levons simplement y j au carr. Le nouveau rsultat est y j1 = y2j .
Dans tous les cas nous avons : y j1 = y2j (xa j1 ).
Do, y p1 = y2p (xa p1 ) = (xa p )2 (xa p1 ) = (x2a p ) (xa p1 ) = (x2a p +a p1 ). Par rcurrence, nous pouvons
i=p
montrer que y1 = xi=0 ai 2 = xn ...

i
1.2. MOTIVATION : CALCUL DE X N
11
Complexit (cot)
Note : les nombres dont la reprsentation binaire a exactement p chiffres forment exactement lintervalle [2 p1 , 2 p 1].
Nombres de chiffres dans lcriture binaire de n : 1+[log2 n]. Notons (n) le nombre de 1 dans lcriture binaire
de n. Nombre doprations effectues :
(1 + [log2 n]) 1 lvations au carr (ne pas oublier ltape 3) ;
(n) 1 multiplications par x (ne pas oublier ltape 3).
Soit en tout T (n) = [log2 n] + (n) 1 multiplications. Trivialement, 1 (n) [log2 n] et [log2 n] T (n) 2[log2 n].
Pour n = 1000, lalgorithme trivial effectue 999 multiplications, et la mthode binaire moins de 20.
Historique
Cette mthode a t prsente avant 200 avant J.C. en Inde, mais il semblerait quil ait fallu attendre un millnaire
avant que cette mthode ne soit connue en dehors de lInde [3, p. 441].
Peut-on faire mieux ?
Prenons le cas n = 15.
1. n = 1111
1 1 1
2.
SX SX SX SX
3.
SX SX SX
4. Nous partons de x et nous obtenons successivement : x2 , x3 , x6 , x7 , x14 , x15 . Nous sommes donc capables de
calculer x15 en 6 multiplications.
Autre schma de calcul : x2 , x3 , x6 , x12 , x15 = x12 x3 . Nous obtenons ainsi x15 en 5 multiplications et la mthode
binaire nest donc pas optimale (cest--dire que lon peut faire mieux).
1.2.4 Algorithme des facteurs

Algorithme
xn1 x
xn =
0
(x p )n
si n = 1;
si n premier;
si n = p n0 avec p plus petit diviseur premier de n.
1. 15 = 3 5, 3 tant le plus petit diviseur (facteur) premier de 15. Donc x15 = (x3 )5 .
Nous rappliquons lalgorithme pour calculer x3 et y5 , o y = x3 .
2. Calcul de x3 :
(a) 3 est premier. Donc x3 = x2 x. Nous rappliquons lalgorithme pour calculer x2 .
(b) 2 est premier. Donc x2 = x x.
(c) Finalement, x3 est calcul comme suit : x3 = x x x, soit en deux multiplications.
3. Calcul de y5 :
(a) 5 est premier. Donc y5 = y4 y. Nous rappliquons lalgorithme pour calculer y4 .
(b) 4 = 2 2, o 2 est le plus petit facteur premier de 4. Donc y4 = (y2 )2 .
(c) Finalement y5 est calcul comme suit : t = y y, u = t t, y5 = u y, soit en 3 multiplications.
4. Finalement, x15 est calcul en 5 multiplications.
12
CHAPITRE 1. INTRODUCTION
Peut-on faire mieux ?

Oui...
1.2.5
Algorithme de larbre
Le k + 1e niveau de larbre est dfini comme suit :

on suppose que lon a dj les k premiers niveaux ;
on construit le k + 1e de la gauche vers la droite en ajoutant sous le nud n les nuds de valeur n + 1, n + a1 , ...,
n + ak1 o 1, a1 , ..., ak1 est le chemin de la racine au nud n ;
on supprime tous les nuds qui dupliquent une valeur dj obtenue.
Cf. la figure 1.1.
F IG . 1.1 Arbre de puissances (minimisant le nombre

de multiplications pour n 76 [3]).
F IG . 1.2 Schma de calcul pour n = 23.
Sur la figure 1.2 nous pouvons constater que cette mthode permet de calculer x23 en 6 multiplications, au lieu de
7 pour la mthode binaire et celle des facteurs... Cette mthode nest optimale que pour n 76.
1.2.6
Et aprs ?
K NUTH [3] consacre prs de 26 pages ce problme...

Moralit : nous avons affaire un problme simple, que tout le monde sait rsoudre, mais quil est trs difficile de
rsoudre efficacement...
Dans ce cours nous verrons des problmes classiques, des mthodes classiques de rsolutions (qui ne rsoudrons
pas tout, loin sen faut), des structures de donnes classiques.
1.3
Conclusion
Pour conclure, citons [2] : Un bon algorithme est comme un couteau tranchant il fait exactement ce que lon
attend de lui, avec un minimum defforts. Lemploi dun mauvais algorithme pour rsoudre un problme revient
essayer de couper un steak avec un tournevis : vous finirez sans doute par obtenir un rsultat digeste, mais vous accomplirez beaucoup plus defforts que ncessaire, et le rsultat aura peu de chances dtre esthtiquement satisfaisant.
Chapitre 2
Complexit et optimalit ; premier

algorithme de tri
2.1 Dfinition de la complexit
2.1.1
Notations de Landau
Quand nous calculerons la complexit dun algorithme, nous ne calculerons gnralement pas sa complexit
exacte, mais son ordre de grandeur. Pour ce faire, nous avons besoin de notations asymptotiques.
n0 , c 0, n n0 , f (n) c g(n)
f = O(g)
f = (g) g = O( f )
f = o(g)
c 0, n0 , n n0 , f (n) c g(n)
f = (g)
f = O(g) et g = O( f )
Exemples
O : n = O(n), 2n = O(3n), n + 2 = O(n) (pour sen convaincre, prendre n0 = 2 et c = 2),
n = O(n2 ).
o : n = o(n), log(n) = o(n), n = o(n2 ), log(n) = o( n).
: n + log(n) = (n + n).
2.1.2
n = O(n), log(n) = O(n),
Complexit
Dfinition 2 (Complexit). La complexit dun algorithme est la mesure du nombre doprations fondamentales quil
effectue sur un jeu de donnes. La complexit est exprime comme une fonction de la taille du jeu de donnes.
Nous notons Dn lensemble des donnes de taille n et T (d) le cot de lalgorithme sur la donne d.
Complexit au meilleur : Tmin (n) = mindDn C(d). Cest le plus petit nombre doprations quaura excuter lalgorithme sur un jeu de donnes de taille fixe, ici n. Cest une borne infrieure de la complexit de lalgorithme
sur un jeu de donnes de taille n.
Complexit au pire : Tmax (n) = maxdDn C(d). Cest le plus grand nombre doprations quaura excuter lalgorithme sur un jeu de donnes de taille fixe, ici n.
Avantage : il sagit dun maximum, et lalgorithme finira donc toujours avant davoir effectu Tmax (n) oprations.
Inconvnient : cette complexit peut ne pas reflter le comportement usuel de lalgorithme, le pire cas pouvant
ne se produire que trs rarement, mais il nest pas rare que le cas moyen soit aussi mauvais que le pire cas.
13
14
CHAPITRE 2. COMPLEXIT ET OPTIMALIT ; PREMIER ALGORITHME DE TRI
C(d)
n
Complexit en moyenne : Tmoy (n) = dD
. Cest la moyenne des complexits de lalgorithme sur des jeux de
|Dn |
donnes de taille n (en toute rigueur, il faut bien videmment tenir compte de la probabilit dapparition de
chacun des jeux de donnes).
Avantage : reflte le comportement gnral de lalgorithme si les cas extrmes sont rares ou si la complexit
varie peu en fonction des donnes.
Inconvnient : la complexit en pratique sur un jeu de donnes particulier peut tre nettement plus importante
que la complexit en moyenne, dans ce cas la complexit en moyenne ne donnera pas une bonne indication du
comportement de lalgorithme.
En pratique, nous ne nous intresserons qu la complexit au pire et la complexit en moyenne.

Dfinition 3 (Optimalit). Un algorithme est dit optimal si sa complexit est la complexit minimale parmi les
algorithmes de sa classe.
Nous nous intresserons quasi exclusivement la complexit en temps des algorithmes. Il est parfois intressant de
sintresser dautres de leurs caractristiques, comme la complexit en espace (taille de lespace mmoire utilis), la
largeur de bande passante requise, etc.
2.1.3
Modle de machine
Pour que le rsultat de lanalyse dun algorithme soit pertinent, il faut avoir un modle de la machine sur laquelle
lalgorithme sera implment (sous forme de programme). On prendra comme rfrence un modle de machine
accs alatoire (RAM) et processeur unique, o les instructions sont excutes lune aprs lautre, sans oprations
simultanes.
2.2
2.2.1
Illustration : cas du tri par insertion

Problmatique du tri
Entre : une squence de n nombres, a1 , ..., an .

Sortie : une permutation, a01 , ..., a0n , de la squence dentre, telle que a01 a02 ... a0n .
2.2.2
Principe du tri par insertion
De manire rpte, on retire un nombre de la squence dentre et on linsre la bonne place dans la squence
des nombres dj tris (ce principe est le mme que celui utilis pour trier une poigne de cartes).
2.2.3
Algorithme
T RI -I NSERTION
Pour j 2 n faire
cl A[ j]
i j1
tant que i > 0 et A[i] > cl faire
A[i + 1] A[i]
i i1
A[i + 1] cl
2.2.4
On retire un nombre de la squence dentre

Les j 1 premiers lments de A sont dj tris.
Tant que lon nest pas arriv au dbut du tableau,
et que llment courant est plus grand que celui insrer.
On dcale llment courant (on le met dans la place vide).
On sintresse llment prcdent.
Finalement, on a trouv o insrer notre nombre.
Exemple
Les diffrentes tapes de lexcution de lalgorithme T RI -I NSERTION sur le tableau [5; 2; 4; 6; 1; 3] sont prsentes
figure 2.1.
15
2.2. ILLUSTRATION : CAS DU TRI PAR INSERTION
F IG . 2.1 Action de T RI -I NSERTION sur le tableau [5; 2; 4; 6; 1; 3] ; llment insrer est entour par un cercle.
2.2.5
Complexit
Nous passons en revue les diffrentes tapes de notre algorithme afin dvaluer son temps dexcution. Pour ce
faire, nous attribuons un cot en temps chaque instruction, et nous comptons le nombre dexcutions de chacune des
instructions. Pour chaque valeur de j [2, n], nous notons t j le nombre dexcutions de la boucle tant que pour cette
valeur de j. Il est noter que la valeur de t j dpend des donnes...
T RI -I NSERTION
Cot
Nombre dexcutions
Pour j 2 n faire
c1
n
cl A[ j]
c2
n1
i j1
c3
n1
tant que i > 0 et A[i] > cl faire
c4
nj=2 t j
A[i + 1] A[i]
c5
nj=2 (t j 1)
c6
i i1
nj=2 (t j 1)
c7
A[i + 1] cl
n1
Le temps dexcution total de lalgorithme est alors :
n
j=2
j=2
j=2
T (n) = c1 n + c2 (n 1) + c3 (n 1) + c4 t j + c5 (t j 1) + c6 (t j 1) + c7 (n 1)
Complexit au meilleur : le cas le plus favorable pour lalgorithme T RI -I NSERTION est quand le tableau est dj
tri, comme le montre le cas j = 4 de la figure 2.1. Dans ce cas t j = 1 pour tout j.
T (n) = c1 n + c2 (n 1) + c3 (n 1) + c4 (n 1) + c7 (n 1)
= (c1 + c2 + c3 + c4 + c7 )n (c2 + c3 + c4 + c7 ).
T (n) peut ici tre crit sous la forme T (n) = an + b, a et b tant des constantes indpendantes des entres, et
T (n) est donc une fonction linaire de n.
Le plus souvent, comme cest le cas ici, le temps dexcution dun algorithme est fix pour une entre donne ;
mais il existe des algorithmes alatoires intressants dont le comportement peut varier mme pour une entre
fixe. Nous verrons un algorithme de ce style au chapitre 4 : une version alatoire du tri rapide
Complexit au pire : le cas le plus dfavorable pour lalgorithme T RI -I NSERTION est quand le tableau est dj tri
dans lordre inverse, comme le montre le cas j = 5 de la figure 2.1. Dans ce cas t j = j pour tout j.
Rappel : nj=1 j =
n(n+1)
2 .
Donc nj=2 j =
n(n+1)
2
1 et nj=2 ( j 1) =
n(n1)
2 .

n(n+1)
n(n1)
n(n1)
T (n) = c1 n + c2 (n 1) + c3 (n 1) + c4
1 + c5
+ c6
+ c7 (n 1)
2
2
2

c
c5 c6 2
c4 c5 c6
4
=
+ +
n + c1 + c2 + c3 + + c7 n (c2 + c3 + c4 + c7 ).
2
2
2
2
2
2
T (n) peut ici tre crit sous la forme T (n) = an2 + bn + c, a, b et c tant des constantes, et T (n) est donc une
fonction quadratique de n.
16
CHAPITRE 2. COMPLEXIT ET OPTIMALIT ; PREMIER ALGORITHME DE TRI
Complexit en moyenne : supposons que lon applique lalgorithme de tri par insertion n nombres choisis au hasard. Quelle sera la valeur de t j ? Cest--dire, o devra-t-on insrer A[ j] dans le sous-tableau A[1.. j 1] ?
En moyenne, pour moiti les lments de A[1.. j 1] sont infrieurs A[ j], et pour moiti suprieurs. Donc
t j = j/2. Si lon reporte cette valeur dans lquation dfinissant T (n), on obtient, comme dans le pire cas, une
fonction quadratique en n.
Caveat : ce raisonnement est partiellement faux ; un raisonnement prcis doit bien videmment tenir compte des
valeurs des lments dj tris. Pour un calcul prcis, voir K NUTH [4, p. 82]. C ORI et L VY [1, p. 26] font un
autre raisonnement et trouve un autre rsultat (de mme ordre de grandeur). Les deux sont justes : tout dpend de
lhypothse que lon prend sur les jeux de donnes. Ainsi [1] suppose que les permutations sont quiprobables,
et [4] que les valeurs trier sont quiprobables...
Ordre de grandeur
Ce qui nous intresse vraiment, cest lordre de grandeur du temps dexcution. Seul le terme dominant de la
formule exprimant la complexit nous importe, les termes dordres infrieurs ntant pas significatifs quand n devient
grand. On ignore galement le coefficient multiplicateur constant du terme dominant. On crira donc, propos de la
complexit du tri par insertion :
meilleur cas : (n).
pire cas : (n2 ).
en moyenne : (n2 ).
En gnral, on considre quun algorithme est plus efficace quun autre si sa complexit dans le pire cas a un ordre
de grandeur infrieur.
Classes de complexit
Les algorithmes usuels peuvent tre classs en un certain nombre de grandes classes de complexit :
Les algorithmes sub-linaires dont la complexit est en gnral en O(log n).
Les algorithmes linaires en complexit O(n) et ceux en complexit en O(n log n) sont considrs comme rapides.
Les algorithmes polynomiaux en O(nk ) pour k > 3 sont considrs comme lents, sans parler des algorithmes
exponentiels (dont la complexit est suprieure tout polynme en n) que lon saccorde dire impraticables
ds que la taille des donnes est suprieure quelques dizaines dunits.
Chapitre 3
La rcursivit
et le paradigme diviser pour rgner
3.1 Rcursivit
De lart dcrire des programmes qui rsolvent des problmes que lon ne sait pas rsoudre soi-mme !
3.1.1
Dfinition
Dfinition 4 (Dfinition rcursive, algorithme rcursif). Une dfinition rcursive est une dfinition dans laquelle
intervient ce que lon veut dfinir. Un algorithme est dit rcursif lorsquil est dfini en fonction de lui-mme.
Dans le cadre de ce cours, nous ne nous intresserons quaux programmes et algorithmes rcursifs. Mais la notion
de dfinition rcursive est beaucoup plus gnrale :
en mathmatiques : dfinition de lexponentielle : x R, f 0 (x) = f (x) et f (0) = 1.
en programmation : dfinition en Ocaml dune liste infinie dont tous les lments valent 1 :
let rec z = 1::z ; ;
3.1.2
Rcursivit simple
Revenons la fonction puissance x 7 xn . Cette fonction peut tre dfinie rcursivement :

1
si n = 0;
n
x =
x xn1 si n 1.
Lalgorithme correspondant scrit :
P UISSANCE (x, n)
Si n = 0 alors renvoyer 1
sinon renvoyer xP UISSANCE(x, n 1)
3.1.3
Rcursivit multiple
p
Une dfinition rcursive peut contenir plus dun appel rcursif. Nous voulons calculer ici les combinaisons Cn en
se servant de la relation de Pascal :

1
si p = 0 ou p = n;
p
Cn =
p
p1
Cn1 +Cn1 sinon.
Lalgorithme correspondant scrit :
17
18
CHAPITRE 3. LA RCURSIVIT ET LE PARADIGME DIVISER POUR RGNER
C OMBINAISON (n, p)
Si p = 0 ou p = n alors renvoyer 1
sinon renvoyer C OMBINAISON (n 1, p) + C OMBINAISON (n 1, p 1)
Bref, rien de particulier...
3.1.4
Rcursivit mutuelle
Des dfinitions sont dites mutuellement rcursives si elles dpendent les unes des autres. a peut tre le cas pour
la dfinition de la parit :

vrai
si n = 0;
faux
si n = 0;
pair(n) =
et impair(n) =
impair(n 1) sinon;
pair(n 1) sinon.
Les algorithmes correspondants scrivent :
PAIR (n)
Si n = 0 alors renvoyer vrai
sinon renvoyer I MPAIR (n 1)
3.1.5
I MPAIR (n)
Si n = 0 alors renvoyer faux
sinon renvoyer PAIR (n 1)
Rcursivit imbrique
La fonction dAckermann est dfinie comme suit :
n+1
A(m 1, 1)
A(m, n) =
A(m 1, A(m, n 1))
si m = 0
si m > 0 et n = 0
sinon
do lalgorithme :
ACKERMANN(m, n)
si m = 0
alors n + 1
sinon si n = 0 alors ACKERMANN(m 1, 1)
sinon ACKERMANN(m 1, ACKERMANN(m, n 1))
En rsum : on peut utiliser la rcursivit comme lon veut, peu prs nimporte comment...
3.1.6
Principe et dangers de la rcursivit
Principe et intrt : ce sont les mmes que ceux de la dmonstration par rcurrence en mathmatiques. On doit avoir :
un certain nombre de cas dont la rsolution est connue, ces cas simples formeront les cas darrt de la
rcursion ;
un moyen de se ramener dun cas compliqu un cas plus simple .
La rcursivit permet dcrire des algorithmes concis et lgants.
Difficults :
la dfinition peut tre dnue de sens :
Algorithme A(n)
renvoyer A(n)
il faut tre srs que lon retombera toujours sur un cas connu, cest--dire sur un cas darrt ; il nous faut
nous assurer que la fonction est compltement dfinie, cest--dire, quelle est dfinie sur tout son domaine
dapplications.
Moyen : existence dun ordre strict tel que la suite des valeurs successives des arguments invoqus par la dfinition
soit strictement monotone et finit toujours par atteindre une valeur pour laquelle la solution est explicitement
dfinie.
Lalgorithme ci-dessous teste si a est un diviseur de b.
3.1. RCURSIVIT
19
D IVISEUR (a,b)
Si a 0 alors Erreur
sinon si a b alors a = b (test dgalit)
sinon D IVISEUR(a,b a)
La suite des valeurs b, b a, b 2 a, etc. est strictement dcroissante, car a est strictement positif, et on finit
toujours pas aboutir un couple darguments (a, b) tel que b a est ngatif, cas dfini explicitement.
Cette mthode ne permet pas de traiter tous les cas :
S YRACUSE(n)
Si n = 0 ou n = 1 alors 1
sinon si n mod 2 = 0 alors S YRACUSE (n/2)
sinon S YRACUSE (3 n + 1)
Problme ouvert : lalgorithme est bien dfini et vaut 1 sur N.
Question : Ny a-t-il vraiment aucun moyen de dterminer automatiquement si un algorithme rcursif quelconque va
terminer ? Rponse la section suivante...
3.1.7
Non dcidabilit de la terminaison
Question : peut-on crire un programme qui vrifie automatiquement si un programme donn P termine quand il
est excut sur un jeu de donnes D ?
Entre Un programme P et un jeu de donnes D.
Sortie vrai si le programme P termine sur le jeu de donnes D, et faux sinon.
Dmonstration de la non dcidabilit
Supposons quil existe un tel programme, nomm termine, de vrification de la terminaison. partir de ce
programme on conoit le programme Q suivant :
programme Q
/
rsultat = termine(Q,0)
tant que rsultat = vrai faire attendre une seconde fin tant que
renvoyer rsultat
/ renvoie vrai, la
Supposons que le programme Q qui ne prend pas darguments termine. Donc termine(Q,0)
deuxime instruction de Q boucle indfiniment et Q ne termine pas. Il y a donc contradiction et le programme Q ne
/ renvoie faux, la deuxime instruction de Q ne boucle pas, et le programme Q termine
termine pas. Donc, termine(Q,0)
normalement. Il y a une nouvelle fois contradiction : par consquent, il nexiste pas de programme tel que termine,
cest--dire qui vrifie quun programme termine ou non sur un jeu de donnes...
Le problme de la terminaison est indcidable !
Petit historique : cf. [1, p. 48].
3.1.8
Importance de lordre des appels rcursifs
Fonction qui affiche les entiers par ordre dcroissant, de n jusqu 1 :

D CROISSANT(n)
Si n = 0 alors ne rien faire
sinon afficher n
D CROISSANT(n 1)
Excution pour n = 2 :
20

Appel de D CROISSANT(2)
Affichage de 2.
Affichage de 1.
Lalgorithme ne fait rien.
Rsultat affichage dabord de 2 puis de 1 : laffichage a lieu dans lordre dcroissant.
Intervertissons maintenant lordre de laffichage et de lappel rcursif :
C ROISSANT(n)
Si n = 0 alors ne rien faire
sinon C ROISSANT(n 1)
afficher n
Excution pour n = 2 :
Appel de C ROISSANT(2)
Lalgorithme ne fait rien.
Affichage de 1.
Affichage de 2.
Rsultat affichage dabord de 1 puis de 2 : laffichage a lieu dans lordre croissant.
3.1.9
Exemple dalgorithme rcursif : les tours de Hano
Le problme
Le jeu est constitu dune plaquette de bois o sont plantes trois tiges. Sur ces tiges sont enfils des disques de
diamtres tous diffrents. Les seules rgles du jeu sont que lon ne peut dplacer quun seul disque la fois, et quil
est interdit de poser un disque sur un disque plus petit.
Au dbut tous les disques sont sur la tige de gauche, et la fin sur celle de droite.
Rsolution
Voir la figure 3.1.
Hypothse : on suppose que lon sait rsoudre le problme
pour (n 1) disques.
Principe : pour dplacer n disques de la tige A vers la tige C,
on dplace les (n 1) plus petits disques de la tige A vers la
tige B, puis on dplace le plus gros disque de la tige A vers
la tige C, puis on dplace les (n 1) plus petits disques de
la tige B vers la tige C.
Validit : il ny a pas de viol des rgles possible puisque le
plus gros disque est toujours en bas dune tige et que
lhypothse (de rcurrence) nous assure que nous savons
dplacer le bloc de (n 1) disques en respectant les
rgles.
F IG . 3.1 Mthode de rsolution du jeu des tours de Hano.
3.2. DRCURSIVATION
21
Algorithme
H ANO(n, dpart, intermdiaire, destination)
Si n = 1 alors dplacer le disque suprieur de la tige dpart vers la tige destination
sinon H ANO(n 1, dpart, destination, intermdiaire)
dplacer le disque suprieur de la tige dpart vers la tige destination
H ANO(n 1, intermdiaire, dpart, destination)
Excution avec trois disques
1. Dplace un disque de la tige dpart vers la tige destination
2. Dplace un disque de la tige dpart vers la tige intermdiaire
3. Dplace un disque de la tige destination vers la tige intermdiaire
5. Dplace un disque de la tige intermdiaire vers la tige dpart
6. Dplace un disque de la tige intermdiaire vers la tige destination
Il ne faut pas chercher comprendre comment a marche, mais pourquoi a marche...
Complexit
On compte le nombre de dplacements de disques effectus par lalgorithme H ANO invoqu sur n disques.

1
si n = 1
1
si n = 1
C(n) =
=
1 + 2 C(n 1) sinon
C(n 1) + 1 +C(n 1) sinon
do lon en dduit que C(n) = 2n 1. On a donc ici un algorithme de complexit exponentielle.
3.2
Drcursivation
Drcursiver, cest transformer un algorithme rcursif en un algorithme quivalent ne contenant pas dappels rcursifs.
3.2.1 Rcursivit terminale

Dfinition 5 (Rcursivit terminale). Un algorithme est dit rcursif terminal sil ne contient aucun traitement aprs
un appel rcursif.
Exemple :
A LGORITHME P(U)
si C alors D; P((U))
sinon T
o :
U est la liste des paramtres ;
C est une condition portant sur U ;
D est le traitement de base de lalgorithme (dpendant de U) ;
(U) reprsente la transformation des paramtres ;
T est le traitement de terminaison (dpendant de U).
Avec ces notations, lalgorithme P quivaut lalgorithme suivant :
22
A LGORITHME P(U)
tant que C faire D;U (U)
T
Lalgorithme P est une version drcursive de lalgorithme P.
3.2.2
Rcursivit non terminale
Ici, pour pouvoir drcursiver, il va falloir sauvegarder le contexte de lappel rcursif, typiquement les paramtres
de lappel engendrant lappel rcursif. Originellement, lalgorithme est :
A LGORITHME Q(U)
si C(U) alors D(U); Q((U)); F(U)
sinon T (U)
Les piles sont des structures de stockage (via les primitives empiler et dpiler) qui fonctionnent sur le principe
le dernier entr est le premier sorti (cf. chapitre 5). Les compilateurs utilisent des piles pour stocker les paramtres
des appels de fonctions, et en particulier lors de la transcription des fonctions rcursives. Nous mimons ici lutilisation
des piles pour drcursiver lalgorithme.
Aprs drcursivation on obtiendra donc :
A LGORITHME Q(U)
empiler(nouvel_appel, U)
tant que pile non vide faire
dpiler(tat, V )
si tat = nouvel_appel alors U V
si C(U) alors D(U)
empiler(fin, U)
empiler(nouvel_appel, (U))
sinon T (U)
si tat = fin alors U V
F(U)
Illustration de la drcursivation de lalgorithme Q
Exemple dexcution de Q :
Appel Q(U0 )
C(U0 ) vrai
D(U0 )
Appel Q((U0 ))
C((U0 )) vrai
D((U0 ))
Appel Q(((U0 )))
C(((U0 ))) faux
T (((U0 )))
F((U0 ))
F(U0 )
Lexcution correspondante de Q est prsente figure 3.2. Les instructions de gestion de piles y figurent en italic,
et les instructions de lalgorithme originel (ce qui nous importe) y figurent en gras.
3.3. DIVISER POUR RGNER
23
Appel Q(U0 )
empiler(nouvel_appel, U))
pile = [(nouvel_appel, U0 )]
dpiler(tat, V ))
tat nouvel_appel ; V U0 ; pile = []
U U0
C(U0 ) vrai
D(U0 )
empiler(fin, U))
pile = [(fin, U0 )]
empiler(nouvel_appel, (U)))
pile = [(fin, U0 ) ; (nouvel_appel, (U0 ))]
dpiler(tat, V ))
tat nouvel_appel ; V (U0 ) ; pile = [(fin, U0 )]
U (U0 )
C((U0 )) vrai
D((U0 ))
empiler(fin, U))
pile = [(fin, U0 ) ; (fin, (U0 ))]
empiler(nouvel_appel, (U)))
pile = [(fin, U0 ) ; (fin, (U0 )) ; (nouvel_appel, ((U0 )))]
dpiler(tat, V ))
tat nouvel_appel ; V ((U0 )) ; pile = [(fin, U0 ) ; (fin, (U0 ))]
U ((U0 ))
C(((U0 ))) faux
T(((U0 )))
dpiler(tat, V ))
tat fin ; V (U0 ) ; pile = [(fin, U0 )]
F((U0 ))
dpiler(tat, V ))
tat fin ; V U0 ; pile = []
F(U0 )
F IG . 3.2 Exemple dexcution de lalgorithme drcursiv.
3.2.3
Remarques
Les programmes itratifs sont souvent plus efficaces, mais les programmes rcursifs sont plus faciles crire. Les
compilateurs savent, la plupart du temps, reconnatre les appels rcursifs terminaux, et ceux-ci nengendrent pas de
surcot par rapport la version itrative du mme programme.
Il est toujours possible de drcursiver un algorithme rcursif.
3.3 Diviser pour rgner

3.3.1
Principe
Nombres dalgorithmes ont une structure rcursive : pour rsoudre un problme donn, ils sappellent eux-mmes
rcursivement une ou plusieurs fois sur des problmes trs similaires, mais de tailles moindres, rsolvent les sousproblmes de manire rcursive puis combinent les rsultats pour trouver une solution au problme initial.
Le paradigme diviser pour rgner donne lieu trois tapes chaque niveau de rcursivit :
Diviser : le problme en un certain nombre de sous-problmes ;
24
Rgner : sur les sous-problmes en les rsolvant rcursivement ou, si la taille dun sous-problme est assez rduite,
le rsoudre directement ;
Combiner : les solutions des sous-problmes en une solution complte du problme initial.
3.3.2
Premier exemple : multiplication nave de matrices
Nous nous intressons ici la multiplication de matrices carrs de taille n.

Algorithme naf
Lalgorithme classique est le suivant :
M ULTIPLIER -M ATRICES(A, B)
Soit n la taille des matrices carrs A et B
Soit C une matrice carr de taille n
Pour i 1 n faire
Pour j 1 n faire
ci, j 0
Pour k 1 n faire
ci, j ci, j + ai,k .bk, j
renvoyer C
Cet algorithme effectue (n3 ) multiplications et autant dadditions.
Algorithme diviser pour rgner naf
Dans la suite nous supposerons que n est une puissance exacte de 2. Dcomposons les matrices A, B et C en
sous-matrices de taille n/2 n/2. Lquation C = AB peut alors se rcrire :

r s
a b
e g
=
.
t u
c d
f h
En dveloppant cette quation, nous obtenons :
r = ae + b f ,
s = ag + bh,
t = ce + d f
et u = cg + dh.
Chacune de ces quatre oprations correspond deux multiplications de matrices carrs de taille n/2 et une addition
de telles matrices. partir de ces quations on peut aisment driver un algorithme diviser pour rgner dont la
complexit est donne par la rcurrence :
T (n) = 8T (n/2) + (n2 ),
laddition des matrices carrs de taille n/2 tant en (n2 ).
3.3.3
Analyse des algorithmes diviser pour rgner
Lorsquun algorithme contient un appel rcursif lui-mme, son temps dexcution peut souvent tre dcrit par
une quation de rcurrence qui dcrit le temps dexcution global pour un problme de taille n en fonction du temps
dexcution pour des entres de taille moindre.
La rcurrence dfinissant le temps dexcution dun algorithme diviser pour rgner se dcompose suivant les
trois tapes du paradigme de base :
1. Si la taille du problme est suffisamment rduite, n c pour une certaine constante c, la rsolution est directe et
consomme un temps constant (1).
2. Sinon, on divise le problme en a sous-problmes chacun de taille 1/b de la taille du problme initial. Le temps
dexcution total se dcompose alors en trois parties :
25

(a) D(n) : le temps ncessaire la division du problme en sous-problmes.
(b) aT (n/b) : le temps de rsolution des a sous-problmes.
(c) C(n) : le temps ncessaire pour construire la solution finale partir des solutions aux sous-problmes.
La relation de rcurrence prend alors la forme :

(1)
si n c,
T (n) =
aT (n/b) + D(n) +C(n) sinon,
o lon interprte n/b soit comme bn/bc, soit comme dn/be.
3.3.4
Rsolution des rcurrences
Thorme 1 (Rsolution des rcurrences diviser pour rgner ).

Soient a 1 et b > 1 deux constantes, soit f (n) une fonction et soit T (n) une fonction dfinie pour les entiers positifs
par la rcurrence :
T (n) = aT (n/b) + f (n),
o lon interprte n/b soit comme bn/bc, soit comme dn/be.
T (n) peut alors tre borne asymptotiquement comme suit :
1. Si f (n) = O(n(logb a) ) pour une certaine constante > 0, alors T (n) = (nlogb a ).
2. Si f (n) = (nlogb a ), alors T (n) = (nlogb a log n).
3. Si f (n) = (n(logb a)+ ) pour une certaine constante > 0, et si a f (n/b) c f (n) pour une constante c < 1 et n
suffisamment grand, alors T (n) = ( f (n)).
Remarques :
1. Le remplacement des termes T (n/b) par T (bn/bc) ou T (dn/be) naffecte pas le comportement asymptotique de
la rcurrence [2, section 4.4.2]. On omettra donc en gnral les parties entires.
2. Le thorme 1 ne couvre pas toutes les possibilit pour f (n). Par exemple, il y a un trou entre les cas 1 et 2
quand f (n) est plus petite que nlogb a , mais pas polynomialement. Dans un tel cas, on ne peut tout simplement
pas appliquer le thorme 1.
Retour sur le premier exemple
Utilisons le thorme 1 pour calculer la complexit de notre algorithme de multiplication de matrices diviser
pour rgner naf. Ici, a = 8, b = 2 et f (n) = (n2 ). Donc logb a = 3, nous nous trouvons dans le cas 1 du thorme
(avec = 1), lalgorithme a une complexit en (n3 ) et nous navons rien gagn...
3.3.5 Deuxime exemple : algorithme de Strassen pour la multiplication de matrices

Lalgorithme de Strassen est un algorithme diviser pour rgner qui neffectue que 7 multiplications de matrices,
contrairement 8 dans lalgorithme prcdent, mais qui effectue plus dadditions et de soustractions de matrices, ce
qui est sans consquence une addition de matrices tant gratuite par rapport au cot dune multiplication.
Complexit
La complexit de lalgorithme de Strassen est donne par la rcurrence :
T (n) = 7T (n/2) + (n2 ).
En utilisant le thorme 1, nous obtenons comme complexit : T (n) = (nlog2 7 ) = O(n2,81 ).
26
Algorithme
Il se dcompose en quatre tapes :
1. Diviser les matrices A et B en matrices carrs de taille n/2.
2. Au moyen de (n2 ) additions et soustractions scalaires, calculer 14 matrices ( prciser) A1 , ..., A7 , B1 , ..., B7
carrs de taille n/2.
3. Calculer rcursivement les 7 produits de matrices Pi = Ai Bi , i [1; 7].
4. Calculer les sous-matrices dsires r, s, t et u en additionnant et/ou soustrayant les combinaisons idoines des
matrices Pi ad-hoc, laide de (n2 ) additions et soustractions scalaires.
Produits de sous-matrices
Nous supposons que chaque matrice produit Pi peut scrire sous la forme :
Pi = Ai Bi = (i,1 a + i,2 b + i,3 c + i,4 d).(i,1 e + i,2 f + i,3 g + i,4 h),
o les coefficients i, j et i, j sont tous pris dans lensemble {1; 0; 1}. Nous supposons donc que chaque produit peut
tre obtenu en additionnant et soustrayant certaines des sous-matrices de A, en additionnant et soustrayant certaines
des sous-matrices de B, et en multipliant les deux matrices ainsi obtenues.
Rcrivons lquation dfinissant r :
+1 0 0 0
e
0 +1 0 0 f
r = ae + b f = (a b c d)
0
0 0 0 g
0
0 0 0
h
o + reprsente +1 , . reprsente 0 et - reprsente

dfinissant s, t et u :
e f g
. . +
a
. . .
s = ag + bh = b
. . .
c
. . .
d
t = ce + d f =
u = cg + dh =
a
b
c
d
a
b
c
d
e f
. .
. .
+ .
. +
a
b
c
d
e
.
.
.
.
g
.
.
.
.
e f
+ .
. +
. .
. .
g
.
.
.
.
h
.
.
.
.
-1 . Nous rcrivons de mme les quations

h
.
+
.
.
h
.
.
.
.
f g h
. . .
. . .
. + .
. . +
On remarque que lon peut calculer s par s = P1 + P2 o P1 et P2 sont calcules chacune au moyen dune unique
multiplication de matrice :
. . +
. . . +
. . . .
, P2 = A2 B2 = (a + b).h = ah + bh = . . . + .
P1 = A1 B1 = a.(g h) = ag ah =
. . . .
. . . .
. . . .
. . . .
27

De mme la matrice t peut tre calcule par t = P3 + P4 avec :
.
.
P3 = A3 B3 = (c + d).e = ce + de =
+
+
.
.
.
.
.
.
.
.
.
, P = A4 B4 = d.( f e) = d f de =
. 4
.
. .
. .
. .
+
Pour calculer r et u on introduit une matrice P5 dfinie comme suit :
+
.
P5 = A5 B5 = (a + d).(e + h) =
.
+
.
.
.
.
. +
. .
,
. .
. +
et on cherche obtenir r partir de P5 :
+ . . .
. + . .
=
. . . .
. . . .
+ . . +
. . . .
=
. . . .
+ . . +
+ . . +
. . . .
=
. . . .
+ . . +
+ . . +
. . . .
=
. . . .
+ . . +
. . .
. + . .
+
. . . .
. .

. . . .
. . . .

+
. . . . +
+ . .

. . . .
. . . .

+
. . . . +
+ . .
. . .
. + . .
. . . .
. .

. . .
. . .
+
. . . .
. . . .
Do, en posant
. . . .
. + . +
P6 = A6 B6 = (b d).( f + h)
. . . . ,
. .
on obtient r = P5 + P4 P2 + P6 .
. . . .
. + . +
.
. . . .
. .
.
.
.
.
.
.
.
.
.
28

De mme, on cherche obtenir u partir de P5 :
. . . .
. . . .
u =
. . + .
. . . +

+ . . +
. .
. . . . . . .

=
. . . . + . . +
+ . . +
. .

+ . . +
. . +
. . . . . . .

=
. . . . + . . .
+ . . +
. . .

+ . . +
. . +
. . . . . . .

=
. . . . + . . .
+ . . +
. . .
.
.

.
+
.
.

.
+
.
.
. .
. . .
. + .
. . .

. . . .
. . . .
+
. . .
. . .
.
.
.
+
.
. .
. . .
.
. + .
. . .
Do, en posant
+
.
P7 = A7 B7 = (a c).(e + g) = ae + ag ce cg =

.
. + .
. . .
,
. .
. . .
on obtient u = P5 + P1 P3 P7 .
Discussion
Lalgorithme de Strassen nest intressant en pratique que pour de grandes matrices (n > 45) denses (peu dlments non nuls).
La meilleure borne suprieure connue pour la multiplication de matrices carrs de taille n est environ en O(n2,376 ).
La meilleure borne infrieure connue est en (n2 ) (il faut gnrer n2 valeurs). On ne connat donc toujours pas le
niveau de difficult rel dune multiplication de matrices !
Chapitre 4
Algorithmes de tri
4.1 Tri par fusion
4.1.1
Principe
Lalgorithme de tri par fusion est construit suivant le paradigme diviser pour rgner :
1. Il divise la squence de n nombres trier en deux sous-squences de taille n/2.
2. Il trie rcursivement les deux sous-squences.
3. Il fusionne les deux sous-squences tries pour produire la squence complte trie.
La rcursion termine quand la sous-squence trier est de longueur 1... car une telle squence est toujours trie.
4.1.2
Algorithme
La principale action de lalgorithme de tri par fusion est justement la fusion des deux listes tries.
La fusion
Le principe de cette fusion est simple : chaque tape, on compare les lments minimaux des deux sous-listes
tries, le plus petit des deux tant llment minimal de lensemble on le met de ct et on recommence. On conoit
ainsi un algorithme F USIONNER qui prend en entre un tableau A et trois entiers, p, q et r, tels que p q < r et tels
que les tableaux A[p..q] et A[q + 1..r] soient tris. Lalgorithme est prsent figure 4.1.
Complexit de la fusion
tudions les diffrentes tapes de lalgorithme :
les initialisations ont un cot constant (1) ;
la boucle tant que de fusion sexcute au plus r p fois, chacune de ses itrations tant de cot constant, do
un cot total en O(r p) ;
les deux boucles tant que compltant C ont une complexit respective au pire de q p + 1 et de r q, ces deux
complexits tant en O(r p) ;
la recopie finale cote (r p + 1).
Par consquent, lalgorithme de fusion a une complexit en (r p).
Le tri
crire lalgorithme de tri par fusion est maintenant une trivialit (cf. figure 4.2).
29
30
CHAPITRE 4. ALGORITHMES DE TRI

F USIONNER(A, p, q, r)
i p
j q+1
Soit C un tableau de taille r p + 1
k1
tant que i q et j r faire
si A[i] < A[ j] alors C[k] A[i]
i i+1
sinon C[k] A[ j]
j j+1
k k+1
tant que i q faire C[k] A[i]
i i+1
k k+1
tant que j r faire C[k] A[ j]
j j+1
k k+1
pour k 1 r p + 1 faire
A[p + k 1] C[k]
indice servant parcourir le tableau A[p..q]

indice servant parcourir le tableau A[q + 1..r]
tableau temporaire dans lequel on construit le rsultat
indice servant parcourir le tableau temporaire
boucle de fusion
on incorpore dans C les lments de A[p..q]

qui ny seraient pas encore ; sil y en a,
les lments de A[q + 1..r] sont dj tous dans C
on incorpore dans C les lments de A[q + 1..r]
qui ny seraient pas encore ; sil y en a,
les lments de A[p..q] sont dj tous dans C
on recopie le rsultat dans le tableau originel
F IG . 4.1 Algorithme de fusion de deux sous-tableaux adjacents tris.

T RI -F USION(A, p, r)
si p < r alors q b(p + r)/2c
T RI -F USION(A, p, q)
T RI -F USION(A, q + 1, r)
F USIONNER(A, p, q, r)
F IG . 4.2 Algorithme de tri par fusion.
4.1.3
Complexit
Pour dterminer la formule de rcurrence qui nous donnera la complexit de lalgorithme T RI -F USION, nous
tudions les trois phases de cet algorithme diviser pour rgner :
Diviser : cette tape se rduit au calcul du milieu de lintervalle [p; r], sa complexit est donc en (1).
Rgner : lalgorithme rsout rcursivement deux sous-problmes de tailles respectives n2 , do une complexit en
2T ( n2 ).
Combiner : la complexit de cette tape est celle de lalgorithme de fusion qui est de (n) pour la construction dun
tableau solution de taille n.
Par consquent, la complexit du tri par fusion est donne par la rcurrence :

(1)
si n = 1,
T (n) =
2T ( n2 ) + (n) sinon.
Pour dterminer la complexit du tri par fusion, nous utilisons de nouveau le thorme 1. Ici a = 2 et b = 2, donc
logb a = 1 et nous nous trouvons dans le deuxime cas du thorme : f (n) = (nlogb a ) = (n). Par consquent :
T (n) = (n log n).
Pour des valeurs de n suffisamment grandes, le tri par fusion avec son temps dexcution en (n log n) est nettement
plus efficace que le tri par insertion dont le temps dexcution est en (n2 ).
31
4.2. TRI PAR TAS
4.2 Tri par tas

4.2.1
Dfinition dun tas
Dfinition 6 (Tas). Un tas est un arbre binaire parfait dont tous les niveaux sont complets sauf le dernier qui est
rempli de la gauche vers la droite. Dans un tas, un pre est toujours plus grand que ses deux fils.
Pour un exemple de tas, voir la figure 4.3.
Les tas sont gnralement reprsents et manipuls sous la forme dun tableau :
Un tableau A qui reprsente un tas est un objet deux attributs :
1. longueur(A) qui est le nombre dlments qui peuvent tre stocks dans le tableau A ;
2. taille(A) qui est le nombre dlments stocks dans le tableau A.
La racine est stocke dans la premire case du tableau A[1].
Les lments de larbre sont rangs dans lordre, niveau par niveau, et de gauche droite. Les fonctions daccs
aux lments du tableau sont alors :
P RE(i)
renvoyer bi/2c
F ILS -G AUCHE(i)
renvoyer 2i
F ILS -D ROIT(i)
renvoyer 2i + 1
Proprit des tas : A[P RE(i)] A[i].
16
1
14
2
10
3
8
4
7
5
9
6
3
7
2
8
4
9
1
10
F IG . 4.3 Un tas vu comme un arbre binaire ( gauche) et comme un tableau ( droite). Le nombre lintrieur dun
nud de larbre est la valeur contenue dans ce nud ; le nombre au-dessus est lindice correspondant dans le tableau.
4.2.2
Conservation de la structure de tas
Lalgorithme E NTASSER (cf. figure 4.4) prend en entre un tableau A et un indice i. On suppose que les sous-arbres
de racines G AUCHE(i) et D ROIT(i) sont des tas. Par contre, il est possible que A[i] soit plus petit que ses fils (violant
ainsi la proprit de tas). E NTASSER doit faire descendre la valeur de A[i] de sorte que le sous-arbre de racine i soit
un tas. Laction de cet algorithme est illustr par la figure 4.5.
Correction
Le rsultat de lalgorithme E NTASSER est bien un tas car :
La structure de larbre nest pas modifie.
32
E NTASSER(A, i)
g G AUCHE(i)
d D ROIT(i)
max i
si g taille(A) et A[g] > A[max] alors max g
si d taille(A) et A[d] > A[max] alors max d
si max 6= i alors changer A[i] A[max]
E NTASSER(A, max)
F IG . 4.4 Algorithme E NTASSER
F IG . 4.5 Action de E NTASSER(A, 2) : la configuration initiale (figure gauche) viole la proprit du tas ; pour i = 2
cette proprit est restaure par interversion de la cl avec celle du fils gauche (figure de droite) ; le rsultat nest
toujours pas un tas, et lappel rcursif E NTASSER(A, 4) intervertit la cl du nud i = 4 avec celle de son fils droit ; on
obtient finalement le tas de la figure 4.3.
Un change de valeurs entre un pre et un fils na lieu que si la valeur du fils est suprieure celle du pre. Or
la valeur du pre tait suprieure celles stockes dans ses deux arbres fils excepte la valeur ajoute larbre.
La nouvelle cl de la racine est donc bien plus grande que lintgralit de celles stockes dans larbre dont elle
devient la racine.
Complexit
Le temps dexcution de E NTASSER sur un arbre de taille n est en (1) plus le temps de lexcution rcursive de
E NTASSER sur un des deux sous-arbres, or ces deux sous-arbres ont une taille en au plus 2n
3 (le pire cas survient quand
la dernire range de larbre est exactement remplie moiti). Le temps dexcution de E NTASSER est donc dcrit par
la rcurrence :

2n
T (n) T
+ (1)
3
ce qui, daprs le cas 2 du thorme 1, nous donne : T (n) = (log n), car a = 1, b =
4.2.3
3
2
et logb a = 0.
Construction dun tas
La construction se fait simplement par utilisation successive de lalgorithme E NTASSER, comme le montre lalgorithme la figure 4.6.
Complexit
Premire borne : chaque appel entasser cote O(log2 n) et il y a O(n) appels de ce type. La complexit de
C ONSTRUIRE -TAS est donc en O(n log2 n). On peut en fait obtenir une borne plus fine.
33
4.3. TRI RAPIDE (QUICKSORT)

C ONSTRUIRE -TAS(A, Valeurs)
taille[A] longueur[A]
(A)
Pour i b longueur
c 1 faire E NTASSER(A,i)
2
F IG . 4.6 Algorithme C ONSTRUIRE -TAS.
n
En effet, un tas n lments est de hauteur blog2 nc et une hauteur h il contient au maximum d 2h+1
e nuds. De
plus, lalgorithme E NTASSER requiert un temps dexcution en O(h) quand il est appel sur un tas de hauteur h. Do :
T (n) =
blog2 nc l
j=0
or
n m
2h+1
blog2 nc
O(h) = O n
h=0
h
2h
2h = 2.
h=0
Do :
T (n) = O(n).
On peut donc construire un tas partir dun tableau en temps linaire.
Illustration de lalgorithme C ONSTRUIRE -TAS
Voir la figure 4.7.
4.2.4
Algorithme du tri par tas
T RIER -TAS(A)
C ONSTRUIRE -TAS(A)
Pour i longueur(A) 2 faire
changer A[1] A[i]
taille(A) taille(A) 1
E NTASSER(A,1)
Illustration de lalgorithme T RI -TAS

Voir la figure 4.8.
Complexit
La procdure T RIER -TAS prend un temps O(n log2 n) car lappel C ONSTRUIRE -TAS prend un temps O(n) et que
chacun des n 1 appels E NTASSER prend un temps O(log2 n).
4.3 Tri rapide (Quicksort)

4.3.1
Principe
Le tri rapide est fond sur le paradigme diviser pour rgner , tout comme le tri fusion, il se dcompose donc en
trois tapes :
34
F IG . 4.7 Action de C ONSTRUIRE -TAS sur le tableau [4; 1; 3; 2; 16; 9; 10; 14; 8; 7].
35
8
7
3
i
4
10
2
14
16
i
F IG . 4.8 Action de T RIER -TAS sur le tableau [4; 1; 3; 2; 16; 9; 10; 14; 8; 7].
36
Diviser : Le tableau A[p..r] est partitionn (et rarrang) en deux sous-tableaux non vides, A[p..q] et A[q + 1..r], tels
que chaque lment de A[p..q] soit infrieur ou gal chaque lment de A[q + 1..r]. Lindice q est calcul
pendant la procdure de partitionnement.
Rgner : Les deux sous-tableaux A[p..q] et A[q + 1..r] sont tris par des appels rcursifs.
Combiner : Comme les sous-tableaux sont tris sur place, aucun travail nest ncessaire pour les recombiner, le
tableau A[p..r] est dj tri !
4.3.2
Algorithme
T RI -R APIDE(A, p, r)
si p < r alors q PARTITIONNEMENT(A, p, r)
T RI -R APIDE(A, p, q)
T RI -R APIDE(A, q + 1, r)
Lappel T RI -R APIDE(A, 1, longueur(A)) trie le tableau A. Le point principal de lalgorithme est bien videmment le
partitionnement qui rarrange le tableau A sur place :
PARTITIONNEMENT(A, p, r)
x A[p]
i p1
j r+1
tant que VRAI faire
rpter j j 1 jusqu A[ j] x
rpter i i + 1 jusqu A[i] x
si i < j alors changer A[i] A[ j]
sinon renvoyer j
Exemple de partitionnement :
1. Situation intiale :
1
4
3
6
2
1
5
7
Nous avons donc x = 4, i = 0 et j = 8.
2. On excute la boucle rpter j j 1 jusqu A[ j] x et on obtient j = 5.
3. On excute la boucle rpter i i + 1 jusqu A[i] x , et on obtient i = 1.
4. Aprs lchange on obtient le tableau :
1

7. Aprs lchange on obtient le tableau :
1

10. Comme i = j, lalgorithme se termine et renvoie la valeur 3 .
37
4.3.3
Complexit
Pire cas
Le pire cas intervient quand le partitionnement produit une rgion n 1 lments et une un lment, comme
nous le montrerons ci-aprs. Comme le partitionnement cote (n) et que T (1) = (1), la rcurrence pour le temps
dexcution est :
T (n) = T (n 1) + (n).
Do par sommation :
n
k=1
k=1
T (n) =
(k) = k

= n2 .
Pour montrer que cette configuration est bien le pire cas, montrons que dans tous les cas T (n) = O(n2 ), cest--dire
quil existe une constante c telle que T (n) c n2 . Si T (n) est la complexit au pire :
T (n) = max (T (q) + T (n q)) + (n),
1qn1
o le paramtre q est dans lintervalle [1..n 1] puisque la procdure PARTITIONNEMENT gnre deux rgions de
tailles chacune au moins gale un. Do :

T (n) max cq2 + c(n q)2 + (n).
1qn1
Or lexpression q2 + (n q)2 atteint son maximum lune des extrmits de lintervalle (drive ngative puis positive). Do

max q2 + (n q)2 = 12 + (n 1)2 = n2 2(n 1).
1qn1
et
T (n) cn2 2c(n 1) + (n) cn2 ,
puisque lon peut choisir la constante c assez grande pour que le terme 2c(n 1) domine le terme (n). Du coup, le
temps dexcution du tri rapide (dans le pire cas) est (n2 ).
Meilleur cas
On subodore que le meilleur cas apparat quand la procdure de partitionnement produit deux rgions de taille 2n .
La rcurrence est alors :
n
T (n) = 2T ( ) + (n),
2
ce qui, daprs le cas 2 du thorme 1 nous donne
T (n) = (n log n).
Complexit en moyenne
On suppose que le tableau A ne contient pas deux fois le mme lment.
Version stochastique du tri rapide. Un algorithme est dit stochastique si son comportement est dtermin non
seulement par son entre mais aussi par les valeurs produites par un gnrateur de nombres alatoires. On modifie la
procdure PARTITIONNEMENT pour quelle est un comportement stochastique en utilisant une fonction H ASARD(a,
b) qui renvoie de manire quiprobable un entier entre les nombres a et b.
PARTITIONNEMENT-S TOCHASTIQUE(A, p, r)
i H ASARD(p, r)
changer A[p] A[i]
renvoyer PARTITIONNEMENT(A, p, r)
Le but ici est de faciliter lanalyse de lalgorithme et de minimiser linfluence des configurations pathologiques.
38
Analyse du partitionnement. La valeur q renvoye par PARTITIONNEMENT ne dpend que du rang de x = A[p]
parmi les lments de A[p..r] (le rang dun nombre dans un ensemble tant le nombre dlments qui lui sont infrieurs ou gaux). Du fait de lencapsulation de PARTITIONNEMENT dans PARTITIONNEMENT-S TOCHASTIQUE et de
linterversion de A[p] et dun lment alatoire de A[p..r], rang(x) = i pour i = 1, 2, ..., n avec une probabilit 1n en
posant n = r p + 1 (cest le nombre dlments de lintervalle [p..r]).
Ce qui nous intresse, cest la taille des partitions. Nous avons deux cas considrer :
1. rang(x) = 1. Lalgorithme PARTITIONNNEMENT sarrte alors avec i = j = 1 et la rgion infrieure de la
partition comprend lunique lment A[p] et est de taille 1.
2. rang(x) 2. Il existe alors au moins un lment (strictement) plus petit que x = A[p]. Par consquent, lors
du passage dans la boucle tant que, lindice i sarrte la valeur i = p mais lindice j sarrte une valeur
strictement infrieure p. Un change est alors effectu et A[p] est plac dans la rgion suprieure. Lorsque
PARTITIONNEMENT se termine, chacun des rang(x) 1 lments de la rgion infrieure de la partition est
strictement infrieur x. Ainsi pour chaque i = 1, 2, ..., n 1, la probabilit pour que la rgion infrieure ait i
lment est de 1n
Rcurrence pour le cas moyen. Vu ce qui prcde, le temps moyen requis pour le tri dun tableau de longueur n
vaut donc :
!
n1
1
T (n) =
T (1) + T (n 1) + (T (q) + T (n q)) + (n).
n
q=1
Comme T (1) = (1) et T (n 1) = O(n2 ) (vue ltude du pire cas), on a :

1
1
(T (1) + T (n 1)) =
(1) + O(n2 ) = O(n),
n
n
et ce terme peut tre absorb par le terme (n) de la formule. Ainsi :
T (n) =
1 n1
2 n1
(T (q) + T (n q)) + (n) = T (q) + (n).
n q=1
n q=1
Rsolution de la rcurrence. On suppose par induction quil existe des constantes strictement positives a et b telles
que T (n) an log n + b. Si a et b sont tels que lhypothse est vraie pour n = 1 alors, si lon suppose lhypothse vraie
jusquau rang n 1, on a :
T (n) =
2 n1
2a n1
2b
2 n1
T (q) + (n) (ak log k + b) + (n) =
k log k + (n 1) + (n).
n q=1
n k=1
n k=1
n
Si lon sait que (cf. [2, P. 164]) :

n1
k log k 2 n2 log n 8 n2 ,
k=1
on obtient :
T (n)
2a
n

1 2
1
2b
a
a
n log n n2 + (n 1) + (n) an log n n + 2b + (n) = an log n + b + (n) + b n
2
8
n
4
4
do
T (n) an log n + b,
puisque lon peut choisir a suffisamment grand pour que a4 n domine (n) + b. On en conclut que le temps dexcution
moyen du tri rapide est O(n log n).
Chapitre 5
Structures de donnes lmentaires

5.1 Introduction
En informatique, il existe plusieurs manires de reprsenter la notion mathmatique densemble. Il nexiste pas une
reprsentation qui soit meilleure que les autres dans labsolu : pour un problme donn, la meilleure reprsentation
sera celle qui permettra de concevoir le meilleur algorithme, cest--dire celui le plus esthtique et de moindre
complexit. On parlera parfois densembles dynamiques car nos ensembles seront rarement figs.
Chaque lment de ces ensembles pourra comporter plusieurs champs qui peuvent tre examins ds lors que
lon possde un pointeur ou une rfrence si on prfre utiliser une terminologie plus proche de Java que de C
sur cet lment. Certains ensembles dynamiques supposent que lun des champs de lobjet contient une cl servant
didentifiant.
Ces ensembles supportent potentiellement tout une srie doprations :
R ECHERCHE(S, k) : tant donn un ensemble S et une cl k, le rsultat de cette requte est un pointeur sur un
lment de S de cl k, sil en existe un, et la valeur N IL sinon N IL tant un pointeur ou une rfrence sur
rien .
I NSERTION(S, x) : ajoute lensemble S llment point par x.
S UPPRESSION(S, x) : supprime de lensemble S son lment point par x (si lon souhaite supprimer un lment
dont on ne connat que la cl k, il suffit de rcuprer un pointeur sur cet lment via un appel R ECHERCHE(S,
k)).
Si lensemble des cls, ou lensemble lui-mme, est totalement ordonn, dautres oprations sont possibles :
M INIMUM(S) : renvoie llment de S de cl minimale.
M AXIMUM(S) : renvoie llment de S de cl maximale.
S UCCESSEUR(S, x) : renvoie, si celui-ci existe, llment de S immdiatement plus grand que llment de S
point par x, et N IL dans le cas contraire.
P RDCESSEUR(S, x) : renvoie, si celui-ci existe, llment de S immdiatement plus petit que llment de S
point par x, et N IL dans le cas contraire.
5.2
Piles et files
5.2.1 Piles
Dfinition 7 (Pile). Une pile est une structure de donnes mettant en uvre le principe dernier entr, premier sorti
(LIFO : Last-In, First-Out en anglais).
Llment t de lensemble par lopration S UPPRESSION est spcifi lavance (et donc cette opration ne
prend alors que lensemble comme argument) : llment supprim est celui le plus rcemment insr. Lopration
I NSERTION dans une pile est communment appele E MPILER, et lopration S UPPRESSION, D PILER. La figure 5.1
montre les consquences des oprations E MPILER et D PILER sur une pile.
39
40
CHAPITRE 5. STRUCTURES DE DONNES LMENTAIRES
F IG . 5.1 Exemple de pile : a) initialement la pile contient les valeurs 3, 5 et 2 ; b) tat de la pile aprs lopration
E MPILER(6) ; c) tat de la pile aprs lopration E MPILER(1) ; d) tat de la pile aprs lopration D PILER, qui a
renvoy la valeur 1.
Il est facile dimplmenter une pile au moyen dun tableau, comme le montre la figure 5.2. La seule difficult dans
cette implmentation est la gestion des dbordements de pile qui interviennent quand on tente deffecteur lopration
D PILER sur une pile vide et lopration E MPILER sur un tableau codant la pile qui est dj plein. Ce dernier problme
napparat pas lorsque lon implmente les piles au moyen dune structure de donnes dont la taille nest pas fixe a
priori (comme une liste chane). Les algorithmes ralisant les fonctions E MPILER et D PILER, ainsi que la ncessaire
fonction auxiliaire P ILE -V IDE, sont prsents figure 5.3.
F IG . 5.2 Implmentation dune pile par un tableau : a) tat initial de la pile ; b) nouvel tat aprs les actions E MPI LER (7) et E MPILER (3) ; c) nouvel tat aprs lopration D PILER qui a renvoy la valeur 3.
5.2.2
Files
Dfinition 8 (File). Une file est une structure de donnes mettant en uvre le principe premier entr, premier sorti
(FIFO : First-In, First-Out en anglais).
Llment t de lensemble par lopration S UPPRESSION est spcifi lavance (et donc cette opration ne prend
alors que lensemble comme argument) : llment supprim est celui qui est rest le plus longtemps dans la file. Une
file se comporte exactement comme une file dattente de la vie courante. La figure 5.4 montre les consquences des
oprations I NSERTION et S UPPRESSION sur une file.
On peut implmenter les files au moyen de tableaux. La figure 5.5 illustre limplmentation de files n1 lments
au moyen dun tableau n lments et de deux attributs :
tte(F) qui indexe (ou pointe) vers la tte de la file ;
queue(F) qui indexe le prochain emplacement o sera insr un lment nouveau.
Les lments de la file se trouvent donc aux emplacements tte(F), tte(F)+1, ..., queue(F)-1 (modulo n). Quand
tte(F) = queue(F), la liste est vide. Les algorithmes ralisant les fonctions I NSERTION et S UPPRESSION, ainsi que
41
5.2. PILES ET FILES
P ILE -V IDE(P)
si sommet(P)=0 alors renvoyer V RAI
sinon renvoyer FAUX
E MPILER(P, x)
si sommet(P) = longueur(P) alors erreur dbordement positif
sinon sommet(P) sommet(P)+1
P[sommet(P)] x
D PILER(P)
si P ILE -V IDE(P) alors erreur dbordement ngatif
sinon sommet(P) sommet(P)1
renvoyer P[sommet(P) + 1]
F IG . 5.3 Algorithmes de manipulation des piles implmentes par des tableaux.
F IG . 5.4 Exemple de file : a) initialement la file contient

les valeurs 7, 4, 8, 9, 6 et 1 (de la plus anciennement
la plus rcemment insre) ; b) tat de la file aprs lopration I NSERTION(3) ; c) tat de la file aprs lopration
S UPPRESSION qui a renvoy la valeur 7.
F IG . 5.5 Implmentation dune file par un tableau : a)

tat initial de la file ; b) nouvel tat aprs laction I NSER TION (7) ; d) nouvel tat aprs laction I NSERTION (5) ; d)
nouvel tat aprs lopration S UPPRESSION qui a renvoy la valeur 1.
42
la ncessaire fonction auxiliaire F ILE -V IDE, sont prsents figure 5.6. La seule difficult dans cette implmentation
est la gestion des dbordements de file qui interviennent quand on tente deffectuer lopration S UPPRESSION sur une
pile vide et lopration I NSERTION sur un tableau codant la file qui est dj plein. Ce dernier problme napparat pas
lorsque lon implmente les files au moyen dune structure de donne dont la taille nest pas fixe a priori (comme
une liste doublement chane).
F ILE -V IDE(F)
si tte(F)=queue(F) alors renvoyer V RAI
sinon renvoyer FAUX
I NSERTION(F, x)
si queue(F) + 1 (modulo n) = tte(F) alors erreur dbordement positif
sinon F[queue(F)] x
queue(F) queue(F)+1
S UPPRESSION(F)
si F ILE -V IDE(F) alors erreur dbordement ngatif
sinon tte(F) tte(F)+1
renvoyer F[tte(F)1]
F IG . 5.6 Algorithmes de manipulation des files implmentes par des tableaux.
5.3 Listes chanes

5.3.1
Dfinitions
Dfinition 9 (Liste chane). Une liste chane est une structure de donnes dans laquelle les objets sont arrangs
linairement, lordre linaire tant dtermin par des pointeurs sur les lments.
Chaque lment de la liste, outre le champ cl, contient un champ successeur qui est pointeur sur llment suivant
dans la liste chane. Si le champ successeur dun lment vaut N IL, cet lment na pas de successeur et est donc
le dernier lment ou la queue de la liste. Le premier lment de la liste est appel la tte de la liste. Une liste L est
manipule via un pointeur vers son premier lment, que lon notera T TE(L). Si T TE(L) vaut N IL, la liste est vide.
La figure 5.7 prsente un exemple de liste chane et montre les consquences des oprations I NSERTION et S UP PRESSION sur une telle structure de donnes.
F IG . 5.7 Exemple de liste chane : a) initialement la liste chane contient les valeurs 9, 6, 4 et 1 ; b) tat de la liste
chane aprs lopration I NSERTION(5) ; c) tat de la liste chane aprs lopration S UPPRESSION(4).
Une liste chane peut prendre plusieurs formes :

Liste doublement chane : en plus du champ successeur, chaque lment contient un champ prdcesseur
qui est un pointeur sur llment prcdant dans la liste. Si le champ prdcesseur dun lment vaut N IL, cet
5.3. LISTES CHANES
43
lment na pas de prdcesseur et est donc le premir lment ou la tte de la liste. Une liste qui nest pas
doublement chane est dite simplement chane.
La figure 5.8 prsente un exemple de liste doublement chane et montre les consquences des oprations I N SERTION et S UPPRESSION sur une telle structure de donnes.
F IG . 5.8 Exemple de liste doublement chane : a) initialement la liste contient les valeurs 9, 6, 4 et 1 ; b) tat de la
liste aprs lopration I NSERTION(5) ; c) tat de la liste aprs lopration S UPPRESSION(4).
Trie ou non trie : suivant que lordre linaire des lments dans la liste correspond ou non lordre linaire
des cls de ces lments.
Circulaire : si le champ prccesseur de la tte de la liste pointe sur la queue, et si le champ successeur de la
queue pointe sur la tte. La liste est alors vue comme un anneau.
5.3.2
Algorithmes de manipulation des listes chanes
Recherche
Lalgorithme R ECHERCHE -L ISTE(L, k) trouve le premier lment de cl k dans la liste L par une simple recherche
linaire, et retourne un pointeur sur cet lment. Si la liste ne contient aucun objet de cl k, lalgorithme renvoie N IL.
R ECHERCHE -L ISTE(L, k)
x T TE(L)
tant que x 6= N IL et cl(x) 6= k faire
x successeur(x)
renvoyer x
Cet algorithme manipule aussi bien des listes simplement que doublement que simplement chanes.
Insertion
tant donn un lment x et une liste L, lalgorithme I NSERTION -L ISTE insre x en tte de L.
I NSERTION -L ISTE(L, x)
successeur(x) T TE(L)
si T TE(L) 6= N IL alors prdecesseur(T TE(L)) x
T TE(L) x
prdecesseur(x) N IL
Cet algorithme est crit pour les listes doublement chanes. Il suffit dignorer les deux instructions concernant le
champ prdcesseur pour obtenir lalgorithme quivalent pour les listes simplement chanes.
44
Suppression
Lalgorithme S UPPRESSION -L ISTE limine un lment x dune liste chane L. Cet algorithme a besoin dun pointeur sur llment x supprimer. Si on ne possde que la cl de cet lment, il faut pralablement utiliser lalgorithme
R ECHERCHE -L ISTE pour obtenir le pointeur ncessaire.
S UPPRESSION -L ISTE(L, x)
si prdcesseur(x) 6= N IL
alors successeur(prdcesseur(x)) successeur(x)
sinon T TE(L) successeur(x)
si successeur(x) 6= N IL
alors prdcesseur(successeur(x)) prdcesseur(x)
Cet algorithme est crit pour les listes doublement chanes. Lalgorithme quivalent pour les listes simplement
chanes est plus compliqu puisquavec les listes simplement chanes nous navons pas de moyen simple de rcuprer
un pointeur sur llment qui prcde celui supprimer...
S UPPRESSION -L ISTE(L, x)
si x = T TE(L)
alors T TE(L) successeur(x)
sinon y T TE(L)
tant que successeur(y) 6= x faire y successeur(y)
successeur(y) successeur(x)
5.3.3
Comparaison entre tableaux et listes chanes
Aucune structure de donnes nest parfaite, chacune a ses avantages et ses inconvnients. La figure 5.9 prsente
un comparatif des listes simplement chanes, doublement chanes et des tableaux, tris ou non, sur des oprations
lmentaires. Les complexits indiques sont celles du pire cas. Suivant les oprations que nous aurons effectuer, et
suivant leurs frquences relatives, nous choisirons lune ou lautre de ces structures de donnes.
45
5.3. LISTES CHANES
R ECHERCHE(L, k)
liste chane
simple
non trie
(n)a
liste chane
simple
trie
(n)a
liste chane
double
non trie
(n)a
liste chane
double
trie
(n)a
I NSERTION(L, x)
(1)
(n)e
(1)
(n)e
S UPPRESSION(L, x)
S UCCESSEUR(L, x) h
P RDCESSEUR(L, x) h
M INIMUM(L)
M AXIMUM(L)
(n)
(n)i
(n)i
(n)i
(n)i
(n)
(1)
(n)j
(1)
(n)k
(1)
(n)i
(n)i
(n)i
(n)i
(1)
(1)
(1)
(1)
(n)k
tableau
tableau
non tri
(1)b
(n)c
ou
erreurf
(n)g
(n)i
(n)i
(n)i
(n)i
tri
(1)b
(n)d
(n)c ou
erreurf
(n)g
(1)
(1)
(1)
(1)
a Dans
le pire cas il faut parcourir tous les lments pour se rendre compte que la clef ntait pas dans lensemble.
cl tant lindice de llment dans le tableau.
c Dans le pire cas, il faut allouer un nouveau tableau et recopier tous les lments de lancien tableau dans le nouveau.
d Dans le pire cas, linsertion a lieu dans la premire cas du tableau, et il faut dcaler tous les lments dj prsents.
e Au pire, linsertion a lieu en fin de liste.
f Au cas o lon veut effectuer une insertion dans un tableau dj plein et quil nest pas possible deffectuer une allocation dynamique de tableau,
comme en F ORTRAN 77 ou en PASCAL.
g Dans le pire cas on supprime le premier lment du tableau et il faut dcaler tous les autres lments.
h Au sens de lordre sur la valeur des cls.
i Complexit de la recherche du maximum (ou du minimum) dans un ensemble n lments...
j Complexit de la recherche du maximum dans un ensemble n lments... car il faut entreprendre la recherche du prdcesseur depuis le dbut
de la liste.
k Il faut parcourir la liste en entier pour trouver son dernier lment.
b La
F IG . 5.9 Efficacits respectives des listes chanes et des tableaux.
46
Chapitre 6
Programmation dynamique
La programmation dynamique, comme la mthode diviser pour rgner (cf. section 3.3), rsout les problmes
en combinant les solutions de sous-problmes. La programmation dynamique sapplique quand les sous-problmes ne
sont pas indpendants mais ont des sous-sous-problmes en commun. Dans ce cas, un algorithme diviser pour rgner
fait plus de travail que ncessaire, en rsolvant plusieurs fois les sous-sous-problmes communs. Un algorithme de
programmation dynamique rsout chaque sous-sous-problme une unique fois et mmorise sa solution dans un tableau,
spargnant ainsi le recalcul de la solution chaque fois que le sous-sous-problme est rencontr.
La programmation dynamique est en gnral applique aux problmes doptimisation : ces problmes peuvent
admettre plusieurs solutions, parmi lesquelles on veut choisir une solution optimale (maximale ou minimale pour une
certaine fonction de cot).
Le dveloppement dun algorithme de programmation dynamique peut tre planifi en quatre tapes :
1. Caractriser la structure dune solution optimale.
2. Dfinir rcursivement la valeur dune solution optimale.
3. Calculer la valeur dune solution optimale partant des cas simples (cas darrt des rcursions) et en remontant
progressivement jusqu lnonc du problme initial.
4. Construire une solution optimale pour les informations calcules (si lon souhaite avoir une solution et pas
seulement la valeur dune solution optimale).
6.1 Multiplication dune suite de matrices

On suppose que lon a une suite de n matrices, A1 , ..., An , et que lon souhaite calculer le produit :
A1 A2 ...An .
On peut valuer cette expression en utilisant comme sous-programme lalgorithme classique de multiplications de
matrices (cf. section 3.3.2), aprs avoir compltement parenths cette expression afin de lever toute ambigut sur
lordre des multiplications de matrices un produit de matrices compltement parenths est soit une matrice unique
soit le produit de deux produits de matrice compltement parenthss). La multiplication de matrices tant associative,
le rsultat de la multiplication est indpendant du parenthsage. Il y a ainsi cinq manires diffrentes de calculer le
produit de quatre matrices :
A1 A2 A3 A4 = (A1 (A2 (A3 A4 )))
= (A1 ((A2 A3 )A4 ))
= ((A1 A2 )(A3 A4 ))
= ((A1 (A2 A3 ))A4 )
= (((A1 A2 )A3 )A4 )
Le parenthsage du produit peut avoir un impact crucial sur le cot de lvaluation du produit. Le produit dune matrice
A de taille p q par une matrice B de taille q r produit une matrice C de taille p r en pqr multiplications scalaires.
47
48
CHAPITRE 6. PROGRAMMATION DYNAMIQUE
Considrons trois matrices A1 , A2 et A3 de dimensions respectives 10 100, 100 5 et 5 50. Si on effectue la multiplication de ces trois matrices suivant le parenthsage ((A1 A2 )A3 , on effectue 10 100 5 = 5 000 multiplications
dans un premier temps, puis 10 5 50 = 2 500 dans un deuxime temps, soit 7 500 au total. Si, au contraire, on
effectue la multiplication suivant le parenthsage (A1 (A2 A3 )) on effectue 100 5 50 = 25 000 multiplications dans
un premier temps, puis 10 100 50 = 50 000 dans un deuxime temps, soit 75 000 au total et 10 fois plus quavec
le premier parenthsage !
Problmatique
Problmatique de la multiplication dune suite de matrices : tant donne une suite A1 , ..., An de n matrices, o
pour i = 1, 2, ..., n la matrice Ai est de dimensions pi1 pi , parenthser compltement le produit A1 A2 ...An de faon
minimiser le nombre de multiplications scalaires.
Nombre de parenthsages
Le passage en revue de tous les parenthsages possibles ne donnera pas un algorithme efficace, cest pourquoi il
faut avoir recours une technique plus sophistique.
Soit P(n) le nombre de parenthsages possibles dune squence de n matrices. On peut couper une squence de n
matrices entre la ke et la (k + 1)e , pour k prenant nimporte quelle valeur dans lintervalle [1, n 1], puis parenthser
les deux sous-squences rsultantes indpendamment. Do la rcurrence :

1
si n = 1,
P(n) =
P(k)P(n
k)
si n 2.
n1
k=1
On peut montrer que
n
4
1 n1
= 3/2 .
P(n) = C2n2
n
n
Le nombre de solutions est donc au moins exponentiel en n et la mthode directe consistant effectuer une recherche
exhaustive est donc une stratgie mdiocre...
Structure dun parenthsage optimal
La premire tape du paradigme de la programmation dynamique consiste caractriser la structure dune solution
optimale.
Nous notons Ai.. j la matrice rsultant de lvaluation du produit Ai Ai+1 ...A j1 A j . Un parenthsage optimal de
A1 A2 ...An spare le produit entre Ak et Ak+1 pour une certaine valeur k. Dans notre solution optimale on commence
donc par calculer les matrices A1..k et Ak+1..n puis on les multiplie pour obtenir la matrice A1..n recherche. Le cot
du calcul est donc la somme des cots des calculs des matrices A1..k et Ak+1..n et de leur produit. Par consquent le
parenthsage de la sous-suite A1 ...Ak (et celui de la sous-suite Ak+1 ..An ) doit tre optimal : sinon, on le remplace par
un parenthsage plus conomique, et on obtient un parenthsage global plus efficace que... le parenthsage optimal !
Par consquent, une solution optimale une instance du problme de multiplication dune suite de matrices utilise
uniquement des solutions optimales aux instances des sous-problmes. La sous-structure optimale lintrieur dune
solution optimale est lune des garanties de lapplicabilit de la programmation dynamique.
Rsolution rcursive
La deuxime tape du paradigme de la programmation dynamique consiste dfinir rcursivement la valeur dune
solution optimale en fonction de solutions optimales aux sous-problmes.
Pour le problme de la multiplication dune suite de matrices, on prend comme sous-problmes les problmes
consistant dterminer le cot minimum dun parenthsage de Ai Ai+1 ...A j , pour 1 i < j n. Soit m[i, j] le nombre
minimum de multiplications scalaires ncessaires au calcul de Ai Ai+1 ...A j = Ai.. j .
Pour tout i, m[i, i] = 0 car Ai..i = Ai et aucune multiplication nest ncessaire. Considrons un couple (i, j) avec
i < j. Supposons quun parenthsage optimal spare le produit Ai Ai+1 ...A j entre Ak et Ak+1 . Alors, m[i, j], le cot du
6.1. MULTIPLICATION DUNE SUITE DE MATRICES
49
calcul de Ai.. j est gal au cot du calcul de Ai..k , plus celui de Ak+1.. j , plus celui du produit de ces deux matrices. Nous
avons donc :
m[i, j] = m[i, k] + m[k + 1, j] + pi1 pk p j .
Cette quation ncessite la connaissance de la valeur de k, connaissance que nous navons pas. Il nous faut donc passer
en revue tous les cas possibles et il y en a j i :

0

si i = j,
m[i, j] =
(6.1)
minik< j m[i, k] + m[k + 1, j] + pi1 pk p j
si i < j.
m[i, j] nous donne le cot dune solution optimale. Pour pouvoir construire une telle solution on note s[i, j] une valeur
k telle que m[i, j] = m[i, k] + m[k + 1, j] + pi1 pk p j .
Algorithme rcursif
Une premire solution notre problme pourrait tre lalgorithme C HANE D E M ATRICES -R CURSIF ci-dessous
qui est une utilisation directe de la rcursion 6.1
C HANE D E M ATRICES -R CURSIF(p, i, j)
si i = j alors retourner 0
m[i, j] +
pour k 1 j 1 faire
q C HANE D E M ATRICES -R CURSIF(p, i, k)
+ C HANE D E M ATRICES -R CURSIF(p, k + 1, j)
+ pi1 pk p j
si q < m[i, j] alors m[i, j] q
renvoyer m[i, j]
La complexit de cet algorithme est donn par la rcurrence :

1
si n = 1,
T (n) =
1 + n1
k=1 (T (k) + T (n k) + 1) pour n > 1.
Dans le cas gnral, cette complexit peut se rcrire :
n1
T (n) = 2 T (i) + n.
i=1
Par consquent T (n) 2T (n1) et T (n) = (2n ). La quantit totale de travail effectu par lappel C HANE D E M ATRICES R CURSIF(P, 1, n) est donc au moins exponentiel et est donc prohibitif... Heureusement, on peut mieux faire.
Calcul des cots optimaux
En fait, le nombre de sous-problmes est assez rduit : un problme pour chaque choix de i et de j tels que
1 i j n, soit au total Cn2 + n = (n2 ) choix. Lalgorithme rcursif rencontre chaque sous-problme un grand
nombre de fois (ici, un nombre exponentiel de fois) dans diffrentes branches de larbre des appels rcursifs. Cette
proprit, dite des sous-problmes superposs (des sous-problmes ont des sous-sous-problmes en commun), est le
deuxime indice de lapplicabilit de la programmation dynamique.
Plutt que dimplmenter de manire rcursive lquation 6.1, on aborde la troisime tape du paradigme de la
programmation dynamique : on calcule le cot optimal en utilisant une approche ascendante. Lentre de lalgorithme
O RDONNER -C HANE D E M ATRICES ci-dessous est la squence p0 , p1 , ..., pn des dimensions des matrices. Cet algorithme calcul le cot optimal m[i, j] et enregistre un indice s[i, j] permettant de lobtenir.
O RDONNER -C HANE D E M ATRICES(p)
n longueur(p) 1
pour i 1 n faire m[i, i] 0
50
pour l 2 n faire
pour i 1 n l + 1 faire
j i+l 1
m[i, j] +
pour k 1 j 1 faire
q m[i, k] + m[k + 1, j] + pi1 pk p j
s[i, j] k
renvoyer m et s
Lalgorithme remplit le tableau m en considrant des suites de matrices de longueur croissante. Lquation 6.1
nous montre en effet que le calcul du cot dun produit de m matrices ne dpend que des cots de calcul de suites de
matrices de longueur strictement infrieure. La boucle sur l est une boucle sur la longueur des suites considres.
La figure 6.1 prsente un exemple dexcution de lalgorithme O RDONNER -C HANE D E M ATRICES. Comme m[i, j]
nest dfini que pour i j, seule la partie du tableau m strictement suprieure la diagonale principale est utilise.
Les deux tableaux sont prsents de manire faire apparatre la diagonale principale de m horizontalement, chaque
range horizontale contenant les lments correspondants des chanes de matrices de mme taille. O RDONNER C HANE D E M ATRICES calcule les ranges de m du bas vers le haut, et chaque range de la gauche vers la droite. Dans
notre exemple, un parenthsage optimal cote 15 125 multiplications scalaires.
s
m
1
6
15125
5375
3500
5
5000
1000
A1
A2
A3
A4
A5
A6
4
5
3
3
3
1
2
3
4
3
750
2625
15750
10500
2500
4375
7875
7125
9375
11875
5
5
F IG . 6.1 Tableaux m et s calculs par O RDONNER -C HANE D E M ATRICES pour n = 6 et les dimensions :
30, 35, 15, 5, 10, 20, 25.
Complexit
Un simple coup dil lalgorithme montre que sa complexit est en O(n3 ). Plus prcisment :
T (n) = nl=2 nl+1
i+l2
i=1
k=i 1
nl+1
n
= l=2 i=1 (l 1)
= nl=2 (n l + 1)(l 1)
= nl=2 (l 2 + l(n + 2) (n + 1))
3
= n +5n+12
6
sachant que ni=1 i3 = n(n+1)(2n+1)
. La complexit de lalgorithme O RDONNER -C HANE D E M ATRICES est donc en
6
3
(n ) ce qui est infiniment meilleur que la solution nave numrant tous les parenthsages ou que la solution rcursive, toutes deux de complexit exponentielle.
6.2. LMENTS DE PROGRAMMATION DYNAMIQUE
51
Construction dune solution optimale

Lalgorithme O RDONNER -C HANE D E M ATRICES calcule le cot dun parenthsage optimal, mais neffectue pas
la multiplication de la suite de matrices. Par contre, linformation ncessaire la ralisation dun calcul suivant un
parenthsage optimal est stocke au fur et mesure dans le tableau s : s[i, j] contient une valeur k pour laquelle
une sparation du produit Ai Ai+1 ...A j entre Ak et Ak+1 fourni un parenthsage optimal. Lalgorithme M ULTIPLIER C HANE D E M ATRICES ci-dessous ralise la multiplication et rsout donc notre problme.
M ULTIPLIER -C HANE D E M ATRICES(A, s, i, j)
si j > i
alors X M ULTIPLIER -C HANE D E M ATRICES(A, s, i, s[i, j])
X M ULTIPLIER -C HANE D E M ATRICES(A, s, s[i, j] + 1, j)
renvoyer M ULTIPLIER -M ATRICES(X, Y )
sinon renvoyer Ai
Dans lexemple de la figure 6.1, M ULTIPLIER -C HANE D E M ATRICES(A, s, 1, 6) calcule le produit de la suite de
matrices en suivant le parenthsage :
((A1 (A2 A3 ))((A4 A5 )A6 )),
car s[1, 6] = 3, s[1, 3] = 1 et s[4, 6] = 5.
6.2 lments de programmation dynamique

On examine ici les deux caractristiques principales que doit possder un problme doptimisation pour que la programmation dynamique soit applicable : une sous-structure optimale et des sous-problmes superposs. On examinera
aussi une variante de ce paradigme : le recensement.
6.2.1
Sous-structure optimale
Un problme fait apparatre une sous-structure optimale si une solution optimale au problme fait apparatre des
solutions optimales aux sous-problmes. La prsence dune sous-structure optimale est un bon indice de lutilit de
la programmation dynamique (mais cela peut aussi signifier quune stratgie gloutonne est applicable, cf. chapitre 7).
La sous-structure optimale dun problme suggre souvent une classe de sous-problmes pertinents auxquels on peut
appliquer la programmation dynamique.
6.2.2
Sous-problmes superposs
La seconde caractristique que doit possder un problme doptimisation pour que la programmation dynamique
soit applicable est ltroitesse de lespace des sous-problmes, au sens o un algorithme rcursif doit rsoudre
constamment les mmes sous-problmes, plutt que den engendrer toujours de nouveaux. En gnral, le nombre de
sous-problmes distincts est polynomial par rapport la taille de lentre. Quand un algorithme rcursif repasse sur
le mme problme constamment, on dit que le problme doptimisation contient des sous-problmes superposs. A
contrario, un problme pour lequel lapproche diviser pour rgner est plus adapte gnre le plus souvent des
problmes nouveaux chaque tape de la rcursivit. Les algorithmes de programmation dynamique tirent parti de la
superposition des sous-problmes en rsolvant chaque sous-problme une unique fois, puis en conservant la solution
dans un tableau o on pourra la retrouver au besoin avec un temps de recherche constant.
6.2.3
Recensement
Il existe une variante de la programmation dynamique qui offre souvent la mme efficacit que lapproche usuelle,
tout en conservant une stratgie descendante. Son principe est de recenser les actions naturelles, mais inefficaces,
de lalgorithme rcursif. Comme pour la programmation dynamique ordinaire, on conserve dans un tableau les solutions aux sous-problmes, mais la structure de remplissage du tableau est plus proche de lalgorithme rcursif. Un
algorithme rcursif de recensement maintient jour un lment de tableau pour la solution de chaque sous-problme.
52
Chaque lment contient au dpart une valeur spciale pour indiquer quil na pas encore t rempli. Lorsque le sousproblme est rencontr pour la premire fois durant lexcution de lalgorithme rcursif, sa solution est calcule puis
stocke dans le tableau. chaque nouvelle confrontation avec ce sous-problme, la valeur stocke est simplement
rcupre.
R ECENSEMENT-C HANE D E M ATRICES(p)
n longueur(p) 1
pour i 1 n faire
pour j i n faire
m[i, j] +
renvoyer R CUPRATION -C HANE(p, 1, n)
R CUPRATION -C HANE(p, i, j)
si m[i, j] < + alors renvoyer m[i, j]
si i = j
alors m[i, j] 0
sinon pour k i j 1 faire
q R CUPRATION -C HANE(p, i, k) + R CUPRATION -C HANE(p, k + 1, j) + pi1 pk p j
s[i, j] k
Chacun des (n2 ) lments du tableau m est rempli une unique fois par R CUPRATION -C HANE et chacun de ces
(n2 ) appels R CUPRATION -C HANE requiert un temps en O(n) en excluant le temps pass calculer dautres
lments ventuels. La complexit de R CUPRATION -C HANE est donc en O(n3 ).
En pratique, si tous les sous-problmes doivent tre rsolus au moins une fois, un algorithme ascendant de programmation dynamique bat en gnral un algorithme descendant avec recensement dun facteur constant car il limine
le temps pris par les appels rcursifs et prend moins de temps pour grer le tableau. En revanche, si certains sousproblmes de lespace des sous-problmes nont pas besoin dtre rsolus du tout, la solution du recensement prsente
lavantage de ne rsoudre que ceux qui sont vraiment ncessaires.
Chapitre 7
Algorithmes gloutons
Les algorithmes qui rsolvent les problmes doptimisation parcourent en gnral une srie dtapes, au cours
desquelles ils sont confronts un ensemble doptions. Pour de nombreux problmes doptimisation la programmation
dynamique est une approche trop lourde pour dterminer les meilleures solutions ; dautres algorithmes plus simples et
efficaces y arriveront. Un algorithme glouton fait toujours le choix qui semble le meilleur sur le moment. Autrement
dit, il fait un choix optimal localement, dans lespoir que ce choix mnera la solution optimale globalement.
Les algorithmes gloutons naboutissent pas toujours des solutions optimales, mais la mthode gloutonne est trs
puissante et fonctionne correctement pour des problmes varis.
7.1 Location dune voiture

On considre le problme de la location dune unique voiture. Des clients formulent un ensemble de demandes de
location avec, pour chaque demande, le jour du dbut de la location et le jour de restitution du vhicule. Notre but ici
est daffecter le vhicule de manire satisfaire le maximum de clients possible (et non pas de maximiser la somme
des dures des locations).
Nous disposons donc dun ensemble E des demandes de location avec, pour chaque lment e de E, la date d(e)
du dbut de la location et la date f (e) de la fin de cette location. Nous voulons obtenir un ensemble F maximal de
demandes satisfaites. Cet ensemble F doit vrifier une unique contrainte : deux demandes ne doivent pas se chevaucher
dans le temps, autrement dit une location doit se terminer avant que la suivante ne commence. Cette contrainte scrit
mathmatiquement :
e1 F, e2 F,
d(e1 ) d(e2 ) f (e1 ) d(e2 ).
Algorithme
L OCATION DU NE VOITURE(E)
Tri des lments de E par date de fin croissante.
On obtient donc une suite e1 , e2 , ..., en telle que f (e1 ) f (e2 ) ... f (en ).
F[1] e1
j1
pour i 1 n faire
si d(ei ) f (F[ j]) alors j j + 1
F[ j] e j
renvoyer F
Cet algorithme est glouton car chaque tape il prend la location la moins coteuse : celle qui finit le plus tt
parmi celles qui sont satisfiables.
53
54
CHAPITRE 7. ALGORITHMES GLOUTONS
Preuve de loptimalit de lalgorithme

Soit F = {x1 , x2 , ..., x p } la solution obtenue par lalgorithme glouton, et soit G = {y1 , y2 , ..., yq }, q p, une solution
optimale. Nous voulons montrer que F est optimal, et donc que q = p.
Nous supposons que les ensembles F et G sont classs par dates de fins de location croissantes. Si G ne contient
pas F, il existe un entier k tel que : i < k, xi = yi et xk 6= yk . Par construction de F, xk est une demande de location
qui la date de fin minimale et dont la date de dbut soit postrieure la date de fin de xk1 = yk1 . Par consquent,
f (yk ) f (xk ). On peut alors remplacer G par G0 = {y1 , y2 , ..., yk1 , xk , yk+1 , ..., yq } tout en satisfaisant la contrainte
de non chevauchement des demandes. G0 est une autre solution optimale mais ayant strictement plus dlments en
commun avec F que G. En rptant autant que faire se peut ce procd, on obtient un ensemble H de mme cardinalit
que G et qui contient F. Cet ensemble H ne peut contenir dautres lments que ceux de F car ceux-ci, dbutants aprs
la fin de x p , auraient t ajouts F par lalgorithme glouton. Donc H = F, et F et G ont le mme nombre dlments.
Limites de lalgorithme
Il est primordial, ici, que les demandes soit classes par dates de fin croissantes. Le tableau 7.1 prsente trois
demandes de location classes par dates de dbut croissantes pour lesquelles lalgorithme glouton prsent ci-dessus
nest pas optimal. Pour dvidentes raisons de symtries, classer les demandes par dates de dbut dcroissantes donne
par contre un rsultat optimal.
d
F
e1
2
8
e2
3
4
e3
5
8
TAB . 7.1 Demandes classes par dates de dbut croissantes.
d
F
e1
3
6
e2
5
7
e3
3
5
TAB . 7.2 Demandes classes par dures dcroissantes.
Lalgorithme glouton ne donne pas loptimum si notre but est de maximiser la dure totale de location du vhicule.
Mme si on classe les demandes de location par dures dcroissantes, un algorithme glouton ne donnera pas une
solution optimale, le tableau 7.2 prsentant un contre-exemple. En fait, le problme de la maximisation de cette dure
totale est NP-complet (cf. chapitre 11) et on ne connat pas dalgorithme de complexit polynomiale pour le rsoudre.
Si nous disposons de deux voitures et non plus dune seule, lalgorithme prcdent ne donne plus loptimum.
7.2
lments de la stratgie gloutonne
Un algorithme glouton dtermine une solution aprs avoir effectu une srie de choix. Pour chaque point de dcision, le choix qui semble le meilleur cet instant est retenu. Cette stratgie ne produit pas toujours une solution
optimale. Il existe cependant deux caractristiques qui indiquent quun problme se prte une stratgie gloutonne :
la proprit du choix glouton et une sous-structure optimale.
7.2.1
Proprit du choix glouton
Proprit du choix glouton : on peut arriver une solution globalement optimale en effectuant un choix localement optimal (ou choix glouton). En programmation dynamique on fait un choix chaque tape, mais ce choix dpend
de la solution de sous-problmes, au contraire, dans un algorithme glouton, on fait le choix qui semble le meilleur sur le
moment puis on rsout les sous-problmes qui surviennent une fois le choix fait. Une stratgie gloutonne progresse en
gnral de manire descendante en faisant se succder les choix gloutons pour ramener itrativement chaque instance
du problme une instance plus petite .
7.2.2
Montrer quun choix glouton aboutit un problme similaire mais plus petit ramne la dmonstration de
loptimalit prouver quune solution optimale doit faire apparatre une sous-structure optimale.
7.3. FONDEMENTS THORIQUES DES MTHODES GLOUTONNES
55
Un problme fait apparatre une sous-structure optimale si une solution optimale contient la solution optimale
de sous-problmes. Cette proprit est un indice important de lapplicabilit de la programmation dynamique comme
des algorithmes gloutons. Le sujet du TD 6 montre un exemple de problme qui peut tre rsolu par programmation
dynamique mais pas par un algorithme glouton.
7.3
Fondements thoriques des mthodes gloutonnes
La thorie des matrodes ne couvre pas tous les cas dapplications de la mthode gloutonne, mais elle couvre de
nombreux cas intressants en pratique.
7.3.1
Matrodes
Dfinition 10 (Matrode). Un matrode est un couple M = (E, I) vrifiant les conditions suivantes :
1. E est un ensemble fini non vide.
2. I est une famille non vide de sous-ensembles de E, appels sous-ensembles indpendants de E, telle que si H I
et si F H alors F I (on dit que I est hrditaire). Autrement dit, si I contient un sous-ensemble H de E, I
contient tous les sous-ensembles de H. On remarque que lensemble vide est obligatoirement membre de I.
3. Si F et H sont deux lments de I, avec |F| < |H|, alors il existe (au moins) un lment x H \ F tel que
F {x} I (proprit dchange).
Un premier rsultat sur les matrodes :
Thorme 2. Tous les sous-ensembles indpendants maximaux dun matrode ont la mme taille.
Ce rsultat est une consquence directe de la proprit dchange : si un de ces ensembles, H, est strictement plus
petit que les autres, la proprit dchange nous garantit que I contient un sur-ensemble strict H 0 de H, ce qui contredit
la maximalit de H.
Dfinition 11 (Matrode pondr). Un matrode M = (E, I) est dit pondr si lon dispose dune fonction de pondration w qui affecte un poids strictement positif w(x) chaque lment x de E. La fonction de pondration w stend
aux sous-ensembles de E. Soit F un sous-ensemble quelconque de E :
w(F) =
w(x).
xF
7.3.2
Algorithmes gloutons sur un matrode pondr
De nombreux problmes pour lesquels une approche gloutonne donne les solutions optimales peuvent tre ramens
une recherche dun sous-ensemble indpendant de pondration maximale dans un matrode pondr. Autrement dit,
on dispose dun matrode pondr M = (E, I) et on souhaite trouver un ensemble indpendant F I pour lequel
w(F) est maximis. Un tel sous-ensemble indpendant et qui possde la plus grande pondration possible est appel
sous-ensemble optimal du matrode. Comme la pondration est strictement positive par dfinition, un sous-ensemble
optimal est toujours un sous-ensemble indpendant maximal.
Lalgorithme ci-dessous prend en entre un matrode pondr M = (E, I) et sa fonction de pondration w et retourne
un sous-ensemble optimal F.
G LOUTON(M = (E, I), w)
F 0/
Trier E par ordre de poids dcroissant
pour x E par ordre de poids dcroissant faire
si F {x} I alors F F {x}
renvoyer F
56
CHAPITRE 7. ALGORITHMES GLOUTONS
Cet algorithme est glouton parce quil considre les lments de E par ordre de poids dcroissant et quil ajoute
immdiatement un lment x F si F {x} est indpendant. Si E contient n lments et si la vrification de lindpendance de F {x} prend un temps O( f (n), lalgorithme tout entier sexcute en O(n log n + n f (n)) rappel : le tri
dun ensemble de n lments cote O(n log n).
Le sous-ensemble F de E est indpendant par construction. Nous allons maintenant tablir loptimalit de F.
Thorme 3 (Les matrodes satisfont la proprit du choix glouton). Soit M = (E, I) un matrode pondr de
fonction de pondration w. Supposons que E soit tri par ordre de poids dcroissant. Soit x le premier lment de E
tel que {x} soit indpendant, sil existe. Si x existe, il existe un sous-ensemble optimal F de E contenant x.
Si x nexiste pas, le seul lment de I est lensemble vide. Soit H un sous-ensemble optimal. On utilise H pour
construire, au moyen de la proprit dchange, un ensemble F maximal (de mme cardinalit que H) et contenant x.
Par construction, F et H ne diffrent que dun lment et il existe donc un lment y tel que : F = (H \ {y}) {x}. Par
maximalit du poids de x, w(y) w(x), w(H) w(F) et F est optimal.
Thorme 4. Soit M = (E, I) un matrode quelconque. Si x est un lment de E tel que {x} nest pas lment de I,
alors x nappartient aucun sous-ensemble indpendant F de E.
Autrement dit, un lment qui nest pas utilisable immdiatement ne pourra jamais tre utilis : lalgorithme
/
G LOUTON ne fait donc pas derreur en ne considrant pas les lments de E qui ne sont pas extension de 0.
Thorme 5 (Les matrodes satisfont la proprit de sous-structure optimale). Soit x le premier lment de E
choisi par G LOUTON pour le matrode pondr M = (E, I). Le reste du problme trouver un sous-ensemble indpendant contenant x et de poids maximal se rduit trouver un sous-ensemble indpendant et de poids maximal du
matrode pondr M 0 = (E 0 , I 0 ), o :
E 0 = {y E : {x, y} I},
I 0 = {H E \ {x} : H {x} I},
et o la fonction de pondration de M 0 est celle de M restreinte E 0 .
Une solution de poids maximum sur M contenant x engendre une solution de poids maximum sur M 0 , et vice versa.
Thorme 6 (Validit de lalgorithme glouton sur les matrodes). Si M = (E, I) est un matrode pondr de fonction
de pondration w, alors lappel G LOUTON(M = (E, I), w) renvoie un sous-ensemble optimal.
Chapitre 8
Graphes et arbres
8.1 Graphes
Un graphe orient G est reprsent par un couple (S, A) o S est un ensemble fini et A une relation binaire
sur S. Lensemble S est lensemble des sommets de G et A est lensemble des arcs de G. La figure 8.1 est une
reprsentation graphique du graphe orient G = (S, A) avec lensemble de sommets S = {1, 2, 3, 4, 5, 6} et lensemble
darcs A = {(1, 2), (2, 2), (2, 4), (2, 5), (4, 1), (4, 5), (5, 4), (6, 3)} ; les sommets tant reprsents par des cercles et les
arcs par des flches. On notera que les boucles une boucle tant un arc qui relie un sommet lui-mme sont ici
possibles.
F IG . 8.1 Exemple de graphe orient.
F IG . 8.2 Exemple de graphe non orient.
Dans un graphe non orient G = (S, A), lensemble des artes A nest pas constitu de couples mais de paires
de sommets une paire tant non ordonne contrairement un couple. Par convention, on reprsente larte entre
les sommets u et v non par la notation {u, v} mais, indiffremment, par les notations (u, v) ou (v, u). Dans un graphe
non orient les boucles sont interdites et chaque arte est donc constitue de deux sommets distincts. La figure 8.2
est une reprsentation graphique du graphe non orient G = (S, A) avec lensemble de sommets S = {1, 2, 3, 4, 5, 6} et
lensemble darcs A = {(1, 2), (2, 5), (5, 1), (6, 3)}.
Si (u, v) est un arc dun graphe orient G = (S, A), on dit que (u, v) part du sommet u et arrive au sommet v. Si
(u, v) est une arte dun graphe non orient G = (S, A), on dit que larte (u, v) est incidente aux sommets u et v.
Dans un graphe non orient, le degr dun sommet est le nombre dartes qui lui sont incidentes. Si un sommet
est de degr 0, comme le sommet 4 de la figure 8.2, il est dit isol. Dans un graphe orient, le degr sortant dun
sommet est le nombre darcs qui en partent, le degr (r)entrant est le nombre darcs qui y arrivent et le degr est la
somme du degr entrant et du degr sortant.
Dans un graphe orient G = (S, A), un chemin de longueur k dun sommet u un sommet v est une squence
(u0 , u1 , ..., uk ) de sommets telle que u = u0 , v = uk et (ui1 , ui ) A pour tout i dans {1, ..., k}. Un chemin est lmentaire si ces sommets sont tous distincts. Dans la figure 8.1, le chemin (1, 2, 5, 4) est lmentaire et de longueur 3, mais
le chemin (2, 5, 4, 5) nest pas lmentaire. Un sous-chemin p0 dun chemin p = (u0 , u1 , ..., uk ) est une sous-squence
57
58
CHAPITRE 8. GRAPHES ET ARBRES
contigu de ses sommets. Autrement dit, il existe i et j, 0 i j k, tels que p0 = (ui , ui+1 , ..., u j ). On dfinit dans
les graphes non orients la notion correspondante de chane.
Dans un graphe orient G = (S, A), un chemin (u0 , u1 , ..., uk ) forme un circuit si u0 = uk et si le chemin contient au
moins un arc. Ce circuit est lmentaire si les sommets u1 , ..., uk sont distincts. Une boucle est un circuit de longueur
1. Dans un graphe non orient G = (S, A), une chane (u0 , u1 , ..., uk ) forme un cycle si k 3 et si u0 = uk . Ce cycle est
lmentaire si les sommets u1 , ..., uk sont distincts. Un graphe sans cycle est dit acyclique.
Un graphe non orient est connexe si chaque paire de sommets est relie par une chane. Les composantes
connexes dun graphe sont les classes dquivalence de sommets induites par la relation est accessible partir de .
Le graphe de la figure 8.2 contient trois composantes connexes : {1, 2, 5}, {3, 6} et {4}.
Un graphe orient est fortement connexe si chaque sommet est accessible partir de nimporte quel autre. Les
composantes fortement connexes dun graphe sont les classes dquivalence de sommets induites par la relation
sont accessibles lun partir de lautre . Le graphe de la figure 8.1 contient trois composantes connexes : {1, 2, 4, 5},
{3} et {6}.
On dit quun graphe G0 = (S0 , A0 ) est un sous-graphe de G = (S, A) si S0 S et si A0 A.
8.2 Arbres
Un graphe non orient acyclique est une fort et un graphe non orient connexe acyclique est un arbre. La figure
8.3 prsente un graphe qui nest ni un arbre ni une fort car contenant un cycle ; la figure 8.4 prsente un graphe qui
est une fort mais pas un arbre, puisque ntant pas connexe ; la figure 8.5 prsente un arbre.
F IG . 8.3 Exemple de graphe

contenant un cycle.
F IG . 8.4 Exemple de fort.
F IG . 8.5 Exemple darbre.
Thorme 7 (Proprits des arbres). Soit G = (S, A) un graphe non orient. Les affirmations suivantes sont quivalentes.
1.
2.
3.
4.
5.
6.
G est un arbre.
Deux sommets quelconques de G sont relis par un unique chemin lmentaire.
G est connexe, mais si une arte quelconque est te de A, le graphe rsultant nest plus connexe.
G est connexe et |A| = |S| 1.
G est acyclique et |A| = |S| 1.
G est acyclique, mais si une arte quelconque est ajoute A, le graphe rsultant contient un cycle.
Pour la dmonstration de ce thorme, voir [2, pp. 8991].

Un arbre enracin est un arbre dans lequel lun des sommets se distingue des autres. On appelle ce sommet
la racine. Ce sommet particulier impose en ralit un sens de parcours de larbre et larbre se retrouve orient par
lutilisation qui en est faite... Dans la suite de ce cours, et sauf avis contraire, tous les arbres que nous manipulerons
seront des arbres enracins et nous omettrons de le prciser. En outre, on appellera souvent nuds les sommets des
arbres (enracins). La figure 8.6 prsente deux arbres qui ne diffrent que sils sont considrs comme des arbres
enracins.
Soit x un nud dun arbre T de racine r. Un nud quelconque y sur lunique chemin allant de r x est appel
anctre de x. Si T contient larte (y, x) alors y est le pre de x et x est le fils de y. La racine est le seul nud qui nait
59
8.2. ARBRES
7
12
12
7
3
F IG . 8.6 Exemple darbres qui ne diffrent que sils sont enracins.
pas de pre. Un nud sans fils est un nud externe ou une feuille. Un nud qui nest pas une feuille est un nud
interne. Si y est un anctre de x, alors x est un descendant de y.
Le sous-arbre de racine x est larbre compos des descendants de x, enracin en x. Par exemple, dans le premier
arbre de la figure 8.7, le sous-arbre de racine 8 contient les nuds 8, 6, 5 et 9.
profondeur 0
7
3
8
10
12
5
9
profondeur 1
4
11
profondeur 2
profondeur 3
profondeur 4
12
1
10
8
4
11
5
9
F IG . 8.7 Exemple darbres (enracins) qui ne diffrent que sils sont ordonns.
Le nombre de fils du nud x est appel le degr de x. Donc, suivant quun arbre (enracin) est vu comme un arbre
(enracin) ou un graphe, le degr de ses sommets na pas la mme valeur ! La longueur du chemin entre la racine r et
le nud x est la profondeur de x. La plus grande profondeur que puisse avoir un nud quelconque de larbre T est la
hauteur de T . Les deux arbres prsents figure 8.7 sont de hauteur 4.
Un arbre ordonn est un arbre enracin dans lequel les fils de chaque nud sont ordonns entre eux. Les deux
arbres de la figure 8.7 sont diffrents si on les regarde comme des arbres ordonns... mais ils sont identiques si on les
regarde comme de simples arbres (enracins).
Les arbres binaires se dcrivent plus aisment de manire rcursive. Un arbre binaire T est une structure dfinie
sur un ensemble fini de nuds et qui :
ne contient aucun nud, ou
est form de trois ensembles disjoints de nuds : une racine, un arbre binaire appel son sous-arbre gauche et
un arbre binaire appel son sous-arbre droit.
Un arbre binaire est plus quun arbre ordonn dont chaque nud serait de degr au plus deux : dans un arbre
binaire, si un nud na quun seul fils, la position de ce fils quil soit fils gauche ou fils droit est importante. La
figure 8.8 prsente deux arbres ordonns qui ne sont diffrents que quand ils sont vus comme des arbres binaires.
Dans un arbre binaire complet chaque nud est soit une feuille, soit de degr deux aucun nud nest donc de
degr un.
Un arbre k-aire est une gnralisation de la notion darbre binaire o chaque nud est de degr au plus k et non
plus simplement de degr au plus 2.
60

7
3
8
7
4
3
2
12
4
12
F IG . 8.8 Exemple darbres ordonns qui ne diffrent que quand ils sont vus comme des arbres binaires.
8.3 Parcours
8.3.1
Parcours des arbres
Nous ne considrons ici que des arbres ordonns.
Parcours en profondeur
Dans un parcours en profondeur dabord, on descend le plus profondment possible dans larbre puis, une fois
quune feuille a t atteinte, on remonte pour explorer les autres branches en commenant par la branche la plus
basse parmi celles non encore parcourues ; les fils dun nud sont bien videmment parcourus suivant lordre sur
larbre.
PP(A)
si A nest pas rduit une feuille faire
pour tous les fils u de racine(A) faire dans lordre PP(u)
F IG . 8.9 Algorithme de parcours en profondeur dun arbre.
Les parcours permettent deffectuer tout un ensemble de traitement sur les arbres. La figure 8.10 prsente trois
algorithmes qui affichent les valeurs contenues dans les nuds dun arbre binaire, suivant des parcours en profondeur
prfixe, infixe et postfixe, respectivement.
P RFIXE(A)
si A 6= N IL faire
affiche racine(A)
P RFIXE(F ILS -G AUCHE(A))
P RFIXE(F ILS -D ROIT(A))
I NFIXE(A)
si A 6= N IL faire
I NFIXE(F ILS -G AUCHE(A))
affiche racine(A)
I NFIXE(F ILS -D ROIT(A))
P OSTFIXE(A)
si A 6= N IL faire
P OSTFIXE(F ILS -G AUCHE(A))
P OSTFIXE(F ILS -D ROIT(A))
affiche racine(A)
F IG . 8.10 Parcours prfixe, infixe et postfixe dun arbre.
Parcours en largeur
Dans un parcours en largeur dabord, tous les nuds une profondeur i doivent avoir t visits avant que le
premier nud la profondeur i + 1 ne soit visit. Un tel parcours ncessite que lon se souvienne de lensemble des
branches quil reste visiter. Pour ce faire, on utilise une file (ici note F).
61
8.3. PARCOURS
PL(A)
F {racine(A)}
tant que F 6= 0/ faire
u S UPPRESSION(F)
pour tous les fils v de u faire dans lordre I NSERTION(F, v)
F IG . 8.11 Algorithme de parcours en largeur dun arbre.
8.3.2
Parcours des graphes
Le parcours des graphes se rvle tre un peu plus compliqu que celui des arbres. En effet, les graphes peuvent
contenir des cycles et nous voulons viter de parcourir indfiniment ces cycles ! Pour viter cet cueil on colorie les
sommets des graphes : initialement les sommets sont tous blancs ; lorsquil est rencontr pour la premire fois un
sommet est peint en gris ; lorsque tous ses successeurs dans lordre de parcours ont t visits, un sommet est repeint
en noir.
Parcours en profondeur
PP(G)
pour chaque sommet u de G faire couleur[u] B LANC
pour chaque sommet u de G faire si couleur[u] = B LANC alors V ISITER -PP(G, u, couleur)
V ISITER -PP(G, s, couleur)
couleur[s] G RIS
pour chaque voisin v de s faire
si couleur[v] = B LANC alors V ISITER -PP(G, v, couleur)
couleur[s] N OIR
F IG . 8.12 Algorithme de parcours en profondeur dun graphe.
Parcours en largeur
PL(G, s)
couleur[s] G RIS
pour chaque sommet u de G, u 6= s faire couleur[u] B LANC
F {s}
u S UPPRESSION(F)
pour chaque voisin v de u faire
si couleur[v] = B LANC
alors couleur[v] G RIS
I NSERTION(F, v)
couleur[u] N OIR
F IG . 8.13 Algorithme de parcours en largeur dun graphe.
62
Chapitre 9
Arbres de recherche et arbres de recherche

quilibrs
9.1 Arbres binaires de recherche
9.1.1
Dfinition
Dfinition 12 (Arbre binaire de recherche). Un arbre binaire de recherche est un arbre binaire vrifiant la proprit
suivante : soient x et y deux nuds de larbre, si y est un nud du sous-arbre gauche de x, alors clef (y) clef (x), si
y est un nud du sous-arbre droit de x, alors clef (y) clef (x).
La figure 9.1 prsente deux exemples darbres binaires de recherche. Bien que diffrents, ces deux arbres contiennent
exactement les mmes valeurs.
15
15
6
3
2
18
7
17
6
20
13
17
7
18
13
20
F IG . 9.1 Deux arbres binaires de recherche contenant les mmes valeurs.
9.1.2
Recherches
Recherche dun lment

A RBRE -R ECHERCHER(x, k)
si x = N IL ou k = cl(x) alors renvoyer x
si k <cl(x)
alors renvoyer A RBRE -R ECHERCHER(gauche(x), k)
sinon renvoyer A RBRE -R ECHERCHER(droit(x), k)
Minimum et maximum
A RBRE -M INIMUM(x)
tant que gauche(x) 6= N IL faire x gauche(x)
renvoyer x
A RBRE -M AXIMUM(x)
tant que droit(x) 6= N IL faire x droit(x)
renvoyer x
63
64
CHAPITRE 9. ARBRES DE RECHERCHE ET ARBRES DE RECHERCHE QUILIBRS
Successeur et prdcesseur
Si toutes les cls dans larbre sont distinctes, le successeur dun nud x est le nud contenant la plus petite cl
suprieure x.
x
y
k
A
F IG . 9.2 Localisation du successeur.
Considrons le fragment darbre prsent figure 9.2. De par la proprit des arbres binaires de recherche :
1. Le sous-arbre A ne contient que des cls infrieures k et ne peut contenir le successeur de k.
2. Le sous-arbre B ne contient que des cls suprieures k et peut contenir le successeur de k sil nest pas vide.
3. y dsigne le plus proche anctre de k qui soit le fils gauche de son pre (y = k si k est fils gauche de son pre).
Tous les anctres de k jusqu y sont infrieurs ou gaux k et leurs sous-arbres gauches ne contiennent que des
valeurs infrieures k.
x est le pre de y. Sa valeur est suprieure toutes celles contenues dans son sous-arbre gauche (de racine y) et
donc k et celles de B. Toutes les valeurs de son sous-arbre droit sont suprieures x.
En rsum : si B est non vide, son minimum est le successeur de k, sinon le successeur de k est le premier anctre de k
dont le fils gauche est aussi anctre de k.
A RBRE -S UCCESSEUR(x)
si droit(x) 6= N IL alors renvoyer A RBRE -M INIMUM(droit(x))
y pre(x)
tant que y 6= N IL et x = droit(y) faire
xy
y pre(x)
renvoyer y
9.1.3
Insertion dun lment
Llment ajouter est insr l o on laurait trouv sil avait t prsent dans larbre. Lalgorithme dinsertion,
prsent figure 9.3, recherche donc llment dans larbre et, quand il aboutit la conclusion que llment nappartient
pas larbre (lalgorithme aboutit sur N IL), il insre llment comme fils du dernier nud visit.
9.1.4
Suppression dun lment
La figure 9.4 prsente les diffrents cas de figure que doit traiter lalgorithme de suppression dun lment dans un
arbre binaire de recherche. Lalgorithme, prsent figure 9.5, tient en plus compte des conditions aux limites (changement de racine).
65
9.1. ARBRES BINAIRES DE RECHERCHE
A RBRE -I NSERTION(T , z)
x racine(T )
pre_de_x N IL
tant que x 6= N IL faire
pre_de_x x
si clef (z) < clef (x)
alors x gauche(x)
sinon x droit(x)
pre(z) pre_de_x
si pre_de_x = N IL
alors racine(T ) z
sinon si clef (z) < clef (x)
alors gauche(pre_de_x) z
sinon droit(pre_de_x) z
F IG . 9.3 Algorithme dinsertion dans un arbre binaire de recherche.
15
15
16
12
10
5
20
13
18
16
12
23
20
10
18
23
6
7
(a)
15
15
16
3
10
5
20
12
18
13
20
12
23
10
18
23
13
6
7
(b)
15
10
13
18
23
1
12
10
4
7
15
16
20
12
3
1
15
16
13
18
16
20
23
12
4
10
20
13
18
23
(c)
F IG . 9.4 Les diffrents cas de figure possibles lors de la suppression dun nud dun arbre binaire de recherche (les
nuds supprimer sont en gris fonc) : a) le nud supprimer na pas de fils et on llimine simplement de larbre ;
b) le nud supprimer a un unique fils, on dtache le nud et on relie directement son pre et son fils ; c) le nud
supprimer a deux fils, on le remplace par son successeur (qui, dans ce cas, est toujours le minimum de son fils droit,
nud qui est ici lgrement gris).
66
A RBRE -S UPPRESSION(T , x)
si gauche(x) = N IL et droit(x) = N IL
alors
si pre(x) = N IL
alors racine(T ) N IL
sinon si x = gauche(pre(x))
alors gauche(pre(x)) N IL
sinon droit(pre(x)) N IL
sinon si gauche(x) = N IL ou droit(x) = N IL
alors
si gauche(x) 6= N IL
alors filsde_x gauche(x)
sinon filsde_x droit(x)
pre(filsde_x)pre(x)
si pre(x) = N IL
alors racine(T ) filsde_x
sinon si gauche(pre(x)) = x
alors gauche(pre(x)) filsde_x
sinon droit(pre(x)) filsde_x
sinon
min A RBRE -M INIMUM(droit(x))
cl(y) cl(min)
A RBRE -S UPPRESSION(T, min)
renvoyer racine(T )
F IG . 9.5 Suppression dun lment dans un arbre binaire de recherche.
9.1.5
Complexit
Si h est la hauteur de larbre, on peut aisment montrer que tous les algorithmes prcdents ont une complexit en
O(h). Malheureusement, un arbre binaire quelconque n nuds a une hauteur comprise, en ordre de grandeur, entre
log2 n et n. Pour viter les cas les plus pathologiques, on sintresse des arbres de recherches quilibrs.
9.2 Arbres rouge et noir

Les arbres rouge et noir sont un des schmas darbres de recherche dits quilibrs.
9.2.1
Dfinition
Dfinition 13 (Arbre rouge et noir). Un arbre binaire de recherche est un arbre rouge et noir sil satisfait les
proprits suivantes :
1. Chaque nud est soit rouge, soit noir.
2. Chaque feuille (N IL) est noire.
3. Si un nud est rouge, alors ses deux fils sont noirs.
4. Tous les chemins descendants reliant un nud donn une feuille (du sous-arbre dont il est la racine) contiennent
le mme nombre de nuds noirs.
On appelle hauteur noire dun nud x le nombre de nuds noirs sur un chemin descendant de x une feuille.
La figure 9.6 prsente un exemple darbre rouge et noir.
67
9.2. ARBRES ROUGE ET NOIR

7
11
2
1
N IL N IL
N IL
14
8
N IL N IL
N IL
15
N IL N IL
N IL N IL
F IG . 9.6 Exemple darbre rouge et noir. Les hauteurs noires sont indiques ct des nuds.
9.2.2
Rotations
La figure 9.7 prsente les transformations darbres binaires appeles rotations pour dvidentes raisons. La
figure 9.8 prsente lalgorithme ralisant la rotation gauche (la rotation droite tant bien videmment symtrique). Les
rotations prservent la proprit des arbres de recherche mais pas la proprit des arbres rouge et noir.
ROTATION -D ROITE(T , y)
y
C
x
A
x
A
ROTATION -G AUCHE(T , y)
B
F IG . 9.7 Rotations sur un arbre binaire de recherche.
9.2.3
Insertion
Pour raliser linsertion dans un arbre rouge et noir, on peut essayer dinsrer le nouveau nud comme si larbre
ntait quun vulgaire arbre de recherche. Pour ce qui est du choix de la couleur du nud insr, le noir est a priori
proscrire puisquil provoquerait systmatiquement une violation de la proprit 4. On choisit donc de colorier le
nouveau nud en rouge ce qui provoquera parfois des violations de la proprit 3 : un pre et un fils tant tous les
deux rouges. Nous tudions les diffrents cas de violations. La figure 9.9 prsente une premire srie de configurations pathologiques qui sont transformes en dautres configurations. La figure 9.10 prsente une deuxime srie de
configurations pathologiques, ces configurations l pouvant tre rsolues par lapplication dune ou de deux rotations
suivant les cas. La figure 9.11 prsente lalgorithme dinsertion dun lment dans un arbre rouge et noir obtenu suite
cette tude de cas, et la figure 9.12 prsente de nouveau les diffrents cas pathologiques sur un exemple.
9.2.4
Suppression
Pour supprimer un lment dans un arbre rouge et noir, on commence par appliquer lalgorithme de suppression
pour les arbres de recherche. Si llment supprim tait de couleur rouge, aucune des proprits des arbres rouge et
noir nest viole. Par contre, si le nud supprim tait noir la proprit 4 (tous les chemins descendants dun nud
une feuille contiennent le mme nombre de nuds noirs) peut tre viole. Il nous faut donc rajouter un noir sur
tous les chemins perturbs. Pour ce faire, on rajoute un noir lunique fils du nud supprim (pour lunicit du fils,
voir lalgorithme de suppression figure 9.5). Si ce fils tait rouge, larbre obtenu est un arbre rouge et noir. Si ce fils
tait dj noir, on a deux noirs empils sur un mme nud et il nous faut les rpartir. La figure 9.13 prsente les
68
ROTATION -G AUCHE(T , x)
y droit(x)
droit(x) gauche(y)
si gauche(y) 6= N IL alors pre(gauche(y)) x
pre(y) pre(x)
si pre(y) = N IL
alors racine(T ) y
sinon si x = gauche(pre(x))
alors gauche(pre(x)) y
sinon droit(pre(x)) y
gauche(y) x
pre(x) y
F IG . 9.8 Algorithme de rotation gauche pour un arbre binaire.
Transformation
D
B
x
A
nouvel x
C
nouvel x
C
Transformation
x
A
F IG . 9.9 Premire srie de cas pathologiques rencontrs par lalgorithme dinsertion. Les nuds noirs sont fond
noir, et les rouges sont fond blanc. Ici, seule la proprit 3 est viole, x tant le nud source du problme. Par
consquent, les sous-arbres , , , et sont tous de racine noire et ont tous la mme hauteur noire. Lalgorithme fait
descendre la couleur noire du grand-pre de x sur le pre et loncle de x, ce qui revient faire remonter le problme
dans larbre, seule la proprit 3 pouvant tre viole par cette transformation. Les cas non traits sont symtriques de
ceux prsents.
69

ROTATION -G AUCHE(A)
ROTATION -D ROITE(C)
(b)
B
x
A
A
C
(c)
arbre valide
ROTATION -G AUCHE(A)
(d)
x
B
ROTATION -D ROITE(C)
(a)
x
C
x
B
F IG . 9.10 Deuxime srie de cas pathologiques rencontrs par lalgorithme dinsertion. Les nuds noirs sont
fond noir, et les rouges sont fond blanc. Ici, seule la proprit 3 est viole, x est le nud source du problme et
nous ne sommes pas dans un des cas traits par la figure 9.9. Par consquent, les sous-arbres , , et sont tous de
racine noire et ont tous la mme hauteur noire (et les transformations dun cas lautre prservent cette proprit). Ici
on conjugue des rotations et des changements de couleur des nuds.
diffrents cas de figure possibles et les mthodes de rsolutions associes. Si le nud supprim navait pas de fils, on
rajoute un noir la feuille N IL correspondante de son pre. Pour pouvoir raliser cette manipulation, on utilise une
sentinelle : un nud spcial valant N IL et qui permet de ne pas traiter part les feuilles N IL. La figure 9.14 prsente
lalgorithme de suppression avec utilisation de sentinelles et appel de lalgorithme de correction celui qui rpartit
les noirs surnumraires lui-mme prsent figure 9.15.
9.2.5
Complexit
Thorme 8 (Hauteur des arbres rouge et noir). Un arbre rouge et noir contenant n nuds internes a une hauteur
au plus gale 2 log(n + 1).
On peut montrer par induction que le sous-arbre (dun arbre rouge et noir) enracin en un nud x quelconque
contient au moins 2hn(x) nuds internes, o hn(x) est la hauteur noire de x. Sachant que la hauteur est toujours infrieure au double de la hauteur noire on en dduit la borne du thorme 8.
Ce thorme montre bien que les arbres rouge et noir sont relativement quilibrs : la hauteur dun arbre rouge et
noir est au pire du double de celle dun arbre binaire parfaitement quilibr.
Toutes les oprations sur les arbres rouge et noir sont de cot O(h), cest--dire O(log n), ce qui justifie leur
utilisation par rapport aux arbres binaires de recherche classiques.
70
ROUGE N OIR -I NSERTION(T , x)

A RBRE -I NSERTION(T , x)
couleur(x) ROUGE
tant que x 6= racine(T ) et couleur(pre(x)) = ROUGE faire
si pre(x) = gauche(grand-pre(x))
alors
y droit(grand-pre(x))
si couleur(y) = ROUGE
alors
B cas de la figure 9.9
couleur(pre(x))N OIR
couleur(y)N OIR
couleur(grand-pre(x))ROUGE
x grand-pre(x)
sinon
B cas de la figure 9.10
si x =droit(pre(x))
alors
B cas a) de la figure 9.10
x pre(x)
ROTATION -G AUCHE(T , x)
B cas b) de la figure 9.10
couleur(pre(x))N OIR
couleur(grand-pre(x))ROUGE
ROTATION -D ROITE(T , grand-pre(x))
sinon (mme chose que prcdemment en changeant droit et gauche)
couleur(racine(T ))N OIR
F IG . 9.11 Algorithme dinsertion dans un arbre rouge et noir.
71
11
11
14
2
15
14
15
4
(a)
(b)
11
7
14
11
2
2
15
1
14
5
15
4
4
(c)
(d)
F IG . 9.12 Exemple dinsertion dans un arbre rouge et noir faisant apparatre les diffrents cas de figure pathologiques
pouvant apparatre aprs linsertion. Les nuds noirs sont fond noir, et les rouges sont fond blanc. chaque
fois le nud x et son pre sont tous les deux rouges : a) loncle de x est galement rouge, nous nous trouvons donc
dans le cas de la figure 9.9, le pre et loncle de x sont donc repeints en rouge et son grand-pre en noir, le problme est
alors remont de deux crans ; b) loncle de x est noir et x est le fils gauche de son pre, nous nous trouvons donc dans
le cas a) de la figure 9.10, nous appliquons alors une rotation gauche sur le pre de x et nous aboutissons la situation
du cas suivant ; c) loncle de x est noir, x est le fils droit de son pre et son pre est le fils gauche de son grand-pre,
nous nous trouvons donc dans le cas b) de la figure 9.10, nous appliquons alors une rotation droite sur le grand-pre
de x, lancien grand-pre de x est alors repeint en noir et le pre de x en rouge, ce qui nous donne un arbre rouge et
noir valide.
72
Cas 1
B
x
C nouveau w
B c
B c
Cas 3
D
B c
x
nouvel x
nouv.
w C
Cas 2
B c
x
Cas 4
B
x
F IG . 9.13 Configurations pathologiques pour la suppression dans un arbre rouge et noir. Les nuds fond noir sont
des nuds noirs , ceux fond blanc sont rouges et ceux fond gris sont soit noirs soit rouges . , ,
, , et dsignent des arbres quelconques. Le nud x comporte un noir supplmentaire. (1) Ce cas est transform
en cas 2, 3 ou 4. (2) Le noir supplmentaire est remont sur le pre de x, loncle de x tant repeint en rouge ; si le pre
de x tait rouge larbre est de nouveau valide, sinon on rapplique lalgorithme de correction cette fois-ci sur le pre
de x. (3) Ce cas est transform en cas 4. (4) Le noir supplmentaire est limin par rotation gauche sur le pre de x et
recoloriage du pre et de loncle de x.
A RBRE -RN-S UPPRESSION(T , x)

si gauche(x) = N IL(T ) et droit(x) = N IL(T )
alors
si pre(x) = N IL(T )
alors racine(T ) N IL(T )
sinon
si x = gauche(pre(x))
alors gauche(pre(x)) N IL(T )
sinon droit(pre(x)) N IL(T )
si couleur(x) = N OIR
alors
pre(N IL(T )) pre(x)
RN-C ORRECTION(T , x)
sinon si gauche(x) = N IL(T ) ou droit(x) = N IL(T )
alors
si gauche(x) 6= N IL(T )
alors filsde_x gauche(x)
sinon filsde_x droit(x)
pre(filsde_x)pre(x)
si pre(x) = N IL(T )
alors racine(T ) filsde_x
sinon si gauche(pre(x)) = x
alors gauche(pre(x)) filsde_x
sinon droit(pre(x)) filsde_x
si couleur(x) = N OIR alors
RN-C ORRECTION(T , filsde_x)
sinon
min A RBRE -M INIMUM(droit(x))
cl(y) cl(min)
A RBRE -RN-S UPPRESSION(T, min)
renvoyer racine(T )
F IG . 9.14 Suppression dun lment dans un arbre rouge et noir.
73
74
RN-C ORRECTION(T , x)
tant que x 6= racine(T ) et couleur(x) = N OIR faire
si x = gauche(pre(x))
alors
w droit(pre(x))
si couleur(w) = ROUGE
alors
couleur(w) N OIR
couleur(pre(w)) ROUGE
ROTATION -G AUCHE(T , pre(x))
w droit(pre(x))
si couleur(gauche(w)) = N OIR et couleur(droit(w)) = N OIR
alors
couleur(w) ROUGE
x pre(x)
sinon
si couleur(droit(w)) = N OIR
alors
couleur(gauche(w)) N OIR
couleur(w) ROUGE
ROTATION -D ROITE(T , w)
w droit(pre(x))
B cas 1 de la figure 9.13

couleur(w) couleur(pre(x))
couleur(pre(x)) N OIR
couleur(droit(w))) N OIR
ROTATION -G AUCHE(T , pre(x))
x racine(T )
sinon (mme chose que prcdemment en changeant droit et gauche)
couleur(x) N OIR
F IG . 9.15 Correction dun arbre rouge et noir aprs suppression dun lment.
Chapitre 10
Plus courts chemins

Dans un problme de plus courts chemins, on possde en entre un graphe orient pondr G = (S, A) de fonction
de pondration w : A R. Le poids du chemin p = hv0 , v1 , ..., vk i est la somme des poids de ses arcs :
k
w(p) = w(vi1 , vi ).
i=1
Le poids (u, v) dun plus court chemin dun sommet u un sommet v est bien videmment le minimum des poids des
chemins de u v (si celui-ci est dfini, ce qui peut ne pas tre le cas si le graphe contient un circuit de poids strictement
ngatif). Un plus court chemin dun sommet u un sommet v est alors un chemin de u v de poids (u, v).
10.1 Plus courts chemins origine unique

On souhaite dans cette section trouver les plus courts chemins depuis un sommet origine s et vers nimporte quel
autre sommet.
Dans la suite, [u] dsignera le prdcesseur de u dans lestimation du plus court chemin de s u et d[u] dsignera
la longueur de ce chemin.
10.1.1
Algorithme de Dijkstra
Lalgorithme de Dijkstra rsout le problme de la recherche dun plus court chemin origine unique pour un
graphe orient pondr G = (S, A) dans le cas o tous les arcs ont un poids positif ou nul : (u, v) A, w(u, v) 0.
Lalgorithme de Dijkstra maintient jour un ensemble E des sommets de G dont le plus court chemin partir de
lorigine s est connu et calcul. chaque itration, lalgorithme choisit parmi les sommets de S \ E cest--dire
parmi les sommets dont le plus court chemin partir de lorigine nest pas connu le sommet u dont lestimation
de plus court chemin est minimale. Cet algorithme est donc glouton. Une fois un sommet u choisi, lalgorithme met
jour, si besoin est, les estimations des plus courts chemins de ses successeurs (les sommets qui peuvent tre atteint
directement partir de u).
S OURCE -U NIQUE -I NITIALIZATION initialise les valeurs de [u] et de d[u] pour chaque sommet u : initialement,
il ny a pas de chemin connu de s u (si u 6= s) et u est estim tre une distance infinie de s.
R ELCHER(u, v, w) compare le plus court chemin de s v connu avec une nouvelle proposition (chemin estim de
s u puis arc de u v), et met les diffrentes donnes jour si besoin est.
Lalgorithme est prsent figure 10.1.
Cet algorithme fourni effectivement les plus courts chemins. Lalgorithme glouton fonctionne uniquement parce
que les poids sont positifs. On montre la correction de lalgorithme par rcurrence.
Le premier sommet ajout E est s car d[s] vaut alors 0 quand toutes les autres distances estimes sont infinies.
Supposons qu un instant donn pour chaque sommet u de E, d[u] est bien la longueur du plus court chemin
de s u. On rajoute alors un sommet v E. d[v] est alors minimale parmi les sommets de S \ E. Montrons que
d[v] = (s, v).
75
76
CHAPITRE 10. PLUS COURTS CHEMINS
S OURCE -U NIQUE -I NITIALIZATION[G, s]

pour chaque sommet v de G faire
d[v] +
[v] N IL
d[s] 0
R ELCHER(u, v, w)
si d[v] > d[u] + w(u, v) alors
d[v] d[u] + w(u, v)
[v] u
D IJKSTRA(G, w, s)
S OURCE -U NIQUE -I NITIALIZATION(G, s)
E 0/
F S
u E XTRAIRE -M IN(F)
E E {u}
pour chaque arc (u, v) de G faire
R ELCHER(u, v, w)
F IG . 10.1 Algorithme de Dijkstra pour le calcul des plus courts chemins.
Soit p un plus court chemin de s v Soit y le premier sommet de p nappartenant pas E. Par minimalit de d[v]
on a : d[v] d[y]. De plus on a d[y] = (s, y) : parce que p contient le plus court chemin de s x et donc de s au
prdcesseur z de y, parce que d[z] = (s, z) par hypothse de rcurrence, et finalement parce que z a t relch.
Par positivit des poids, (s, y) (s, v). Donc d[v] d[y] = (s, y) (s, v) et d[v] = (s, v).
La figure 10.2 prsente un exemple dexcution de lalgorithme de Dijkstra.
Complexit
La complexit de lalgorithme dpend de la complexit de lopration E XTRAIRE -M IN. Dans le cas (dfavorable)
o on implmente lensemble F au moyen dun simple tableau, la recherche du minimum cote chaque fois (|F|) =
O(|S|). La boucle tant que sexcutant exactement |S| fois, et chaque arc tant visit une unique fois, la complexit
de lalgorithme est O(|S|2 + |A|) = O(|S|2 ).
10.1.2
Algorithme de Bellman-Ford
Lalgorithme de Bellman-Ford rsout le problme des plus courts chemins avec origine unique dans le cas gnral
o le poids des arcs peut tre ngatif. Appel sur un graphe G = (S, A), lalgorithme de Bellman-Ford renvoie un
boolen indiquant si le graphe contient ou non un circuit de poids strictement ngatif accessible partir de lorigine.
Correction
La correction de lalgorithme de Bellman-Ford peut se montrer par rcurrence sur le nombre darcs des plus courts
chemins : la fin de la ie itration de la premire boucle, les plus courts chemins contenant au plus i arcs sont connus,
la condition que le graphe ne contienne aucun circuit de poids strictement ngatif. |S| 1 itrations suffisent car un
plus court chemin est lmentaire (sans perte de gnralit) et contient donc au plus |S| 1 arcs.
Vu ce qui prcde, lalgorithme renvoie V RAI sil ny a pas de circuit de poids strictement ngatif. Montrons
quil renvoie FAUX sinon. Pour sen convaincre, prenons un circuit c de sommets u0 , u1 , ..., u p1 , u p u0 . Si lalgorithme
77
10.1. PLUS COURTS CHEMINS ORIGINE UNIQUE
10
10
4
5
13
d)
10
9
10
2
c)
10
4
7
b)
a)
14
10
10
7
5
2
0
4
7
e)
f)
F IG . 10.2 Exemple dexcution de lalgorithme de Dijkstra : lorigine est le sommet le plus gauche ; dans chaque
graphe, les sommets noirs sont lments de E, le sommet gris est celui qui va tre rajout E et les arcs en pointills
sont ceux utiliss pour les estimations des plus courts chemins, les longueurs de ces chemins tant indiques dans les
sommets.
B ELLMAN -F ORD(G, s, w)
S OURCE -U NIQUE -I NITIALIZATION(G, s)
pour i 1 |S| 1 faire
pour chaque arc (u, v) A faire
R ELCHER(u, v, w)
pour chaque arc (u, v) A faire
si d[v] > d[u] + w(u, v) alors renvoyer FAUX
renvoyer V RAI
F IG . 10.3 Algorithme de Bellman-Ford pour le calcul des plus courts chemins.
78
renvoie V RAI, alors pour tout i [1, p], on a d(ui ) d(ui1 + w(ui1 , ui ). Par sommation on obtient :
p
p1
i=1
i=1
i=1
i=1
i=0
d(ui ) d(ui1 + w(ui1 , ui ) d(ui )
d(ui + w(c) d(u p ) d(u0 ) + w(c) 0 w(c).
Donc, si lalgorithme renvoie V RAI le graphe ne contient pas de circuit de poids strictement ngatif.
Complexit
Cet algorithme est en (|S|.|A|) car linitialisation et la vrification de la non-existence dun circuit de poids
strictement ngatif sont en (|S|) et (|A|) respectivement, et car la boucle pour sexcute exactement (|S| 1)
fois et que chaque itration visite chaque arc exactement une fois ce qui nous cote (|S|.|A|).
La figure 10.4 prsente un exemple dexcution de cet algorithme.
u
-2
6
-3
7
-4
6
6
-3
7
-4
7
9
2
y
v
4
-3
7
-4
-2
c)
-2
6
b)
7
-4
2
7
a)
u
-3
8
4
-2
-2
-3
8
0
z
7
-4
2
7
7
x
9
d)
-2
y
e)
F IG . 10.4 Exemple dexcution de lalgorithme de Bellman-Ford : lorigine est le sommet le plus gauche ; dans
chaque graphe les arcs en pointills sont ceux utiliss pour les estimations des plus courts chemins, les longueurs de
ces chemins tant indiques dans les sommets. Les arcs sont considrs dans lordre lexicographique : (u, v), (u, x),
(u, y), (v, u), (x, v), (x, y), (y, v), (z, u) et (z, x).
10.2 Plus courts chemins pour tout couple de sommets

Nous nous intressons ici la recherche des plus courts chemins entre tous les couples de sommets dun graphe
(typiquement on cherche laborer la table des distances entre tous les couples de villes dun atlas routier). On dispose
en entre dun graphe G = (S, A) et dune fonction de pondration w.
79
10.2. PLUS COURTS CHEMINS POUR TOUT COUPLE DE SOMMETS
Nous supposons dans cette section quil peut y avoir des arcs de poids ngatifs, mais quil nexiste pas de circuits
de poids strictement ngatifs.
10.2.1
Programmation dynamique nave
Comme nous lavons dj remarqu prcdemment (pour lalgorithme glouton de Dijkstra), tout sous-chemin dun
plus court chemin est lui-mme un plus court chemin.
Rsolution rcursive
(m)
La rcursion porte ici sur le nombre darcs du plus court chemin. On note di, j le poids minimal dun chemin dau
plus m arcs du sommet i au sommet j. Pour m = 0 il existe un plus court chemin sans arc de i vers j si et seulement si
i= j:

0 si i = j,
(0)
di, j =
sinon.
(m)
Pour m 1, di, j est la longueur du plus court chemin de i j contenant au plus m arcs. Soit un tel plus court chemin
contient exactement m arcs et il est obtenu par concatnation dun plus court chemin dau plus m 1 arcs de i un
(m1)
sommet k et de larc de k j, soit il nen contient au plus que m 1 et sa longueur est gale di, j . Par consquent :

n
o
n
o
(m)
(m1)
(m1)
(m1)
di, j = min di, j , min di,k
+ wk, j
= min di,k
+ wk, j ,
1kn
1kn
la formule tant simplifie grce la proprit : w j, j = 0.

Calcul ascendant des poids des plus courts chemins

(m)
On note W = (wi, j )1i, jn le matrice des poids et D(m) = di, j
chemins contenant au plus m arcs. Le calcul de
ci-dessous :
D(m)
partir de
1i, jn
D(m1) et de
la matrice des poids des plus courts

W se fait au moyen de lalgorithme
E XTENSION -P LUS -C OURTS -C HEMINS(D, W )

n lignes(D)
soit D0 = (di,0 j )1i, jn une matrice carre de taille n
pour i 1 n faire
pour j 1 n faire
di,0 j +
pour k 1 n faire
di,0 j min(di,0 j , di,k + wk, j )
renvoyer D0
Lalgorithme E XTENSION -P LUS -C OURTS -C HEMINS sexcute en (n3 ), cause des trois boucles imbriques.
partir de cet algorithme, la rsolution du problme est triviale (cf. figure 10.5). Le cot total de rsolution est donc en
(n4 ).
La figure 10.6 prsente un exemple dexcution de cet algorithme.
10.2.2
Algorithme de Floyd-Warshall
Lalgorithme de Floyd-Warshall est un autre algorithme conu suivant le principe de la programmation dynamique.
80
P LUS -C OURTS -C HEMINS(W )

n lignes(W )
D(1) W
pour m 2 n 1 faire
D(m) E XTENSION -P LUS -C OURTS -C HEMINS(D(m1) ,W )
renvoyer D(n1)
F IG . 10.5 Algorithme naf par programmation dynamique pour le calcul des plus courts chemins.
2
4
3
7
(1)
D(3) =
-4
0 3 8 4
0 1 7
4 0
2 5 0
6 0
0 3 3 2 4
3 0 4 1 1
7 4
0 5 11
2 1 5 0 2
8 5
1 6 0
3
-5
4
(2)
D(4) =
0 3
8 2 4
3 0 4 1 7
4
0 5 11
2 1 5 0 2
8
1 6 0
0 1 3 2 4
3 0 4 1 1
7 4
0 5 3
2 1 5 0 2
8 5
1 6 0
F IG . 10.6 Un graphe orient et la squence des matrices calcules par P LUS -C OURTS -C HEMINS.
81
10.2. PLUS COURTS CHEMINS POUR TOUT COUPLE DE SOMMETS

Structure dun plus court chemin
Ici, la rcursion na pas lieu sur le nombre darcs dun plus court chemin, mais sur les sommets intermdiaires
de ces chemins, un sommet intermdiaire tant un sommet autre que les extrmits du chemin. On note {1, 2, ..., n}
(k)
les n sommets de G. Ici, di, j est la longueur du plus court chemin de i j nutilisant comme sommets intermdiaires
que des sommets parmi {1, 2, ..., k}. De deux choses lune, un plus court chemin de i j nayant comme sommets
intermdiaires que des sommets de {1, 2, .., k} contient ou ne contient pas le sommet k :
1. Si le plus court chemin p de i j et nayant comme sommets intermdiaires que des sommets de {1, 2, .., k} a
p
p
effectivement comme sommet intermdiaire k, alors p est de la forme i 1 k 2 j o p1 (resp. p2 ) est un plus court
chemin de i k (resp. de k j) nayant comme sommets intermdiaires que des sommets de {1, 2, ..., k 1}.
2. Si le plus court chemin p de i j et nayant comme sommets intermdiaires que des sommets de {1, 2, .., k} ne
contient pas k, alors cest un plus court chemin p de i j et nayant comme sommets intermdiaires que des
sommets de {1, 2, .., k 1}.
Rsolution rcursive
(k)
La structure explicite aux paragraphes prcdent nous donne directement une rcursion dfinissant di, j :
(
wi, j
si k = 0,
(k)
di, j =
(k1) (k1)
(k1)
min(di, j , di,k + dk, j ) sinon.
Calcul ascendant des poids des plus courts chemins
F LOYD -WARSHALL(W )
n lignes(W )
D(0) W
pour k 1 n faire
pour i 1 n faire
pour j 1 n faire
(k)
(k1) (k1)
(k1)
di, j min(di, j , di,k + dk, j )
renvoyer D(n)
F IG . 10.7 Algorithme de Floyd-Warshall pour le calcul des plus courts chemins.
Construction des plus courts chemins

Tout comme on a dfini rcursivement les longueurs des plus courts chemins, on peut dfinir rcursivement les
(k)
prdcesseurs dans les plus courts chemins : i, j reprsente ici le prdcesseur du sommet j dans le plus court chemin
de i j nutilisant comme sommets intermdiaires que des sommets parmi {1, 2, ..., k}. Pour k = 0, un plus court
chemin ne possde aucun sommet intermdiaire, donc :

N IL si i = j ou wi, j = ,
(0)
i, j =
i
si i 6= j et wi, j < .
Dans le cas gnral, si le plus court chemin est de la forme i
k
j le prdcesseur de j est le mme que celui
du plus court chemin de k j et nutilisant comme sommets intermdiaires que des sommets parmi {1, 2, ..., k 1}.
Autrement, on prend le mme prdcesseur de j que celui qui se trouvait sur le plus court chemin de i j et nutilisant
comme sommets intermdiaires que des sommets parmi {1, 2, ..., k 1}. Nous avons donc, dans tous les cas :
(k1) si d (k1) d (k1) + d (k1) ,

i, j
i, j
i,k
k, j
(k)
i, j =
(k1) si d (k1) > d (k1) + d (k1) .
i, j
k, j
i,k
k, j
82
Complexit
On remarque aisment que lalgorithme de Floyd-Warshall est de complexit (n3 ).
La figure 10.8 prsente le rsultat de lexcution de lalgorithme de Floyd-Warshall sur le graphe de la figure 10.6.
0 3 8 4
0 1 7
(0)
D =
4 0
2 5 0
6 0
0 3 8 4
0 1 7
(1)
D =
4 0
2 5 5 0 2
6 0
0 3 8 4 4
0 1 7
D(2) =
4 0 5 11
2 5 5 0 2
6 0
0 3
8 4 4
0
1 7
(3)
0 5 11
D = 4
2 1 5 0 2

6 0
0 3 1 4 4
3 0 4 1 1
(4)
0 5 3
D =
7 4
2 1 5 0 2
8 5
1 6 0
0 1 3 2 4
3 0 4 1 1
0 5 3
D(5) =
7 4
2 1 5 0 2
8 5
1 6 0
(0)
(1)
N IL
N IL
N IL
4
N IL
1
N IL
3
N IL
N IL
1
N IL
N IL
4
N IL
N IL
2
N IL
N IL
5
1
2
N IL
N IL
N IL
N IL
N IL
N IL
4
N IL
1
N IL
3
1
N IL
1
N IL
N IL
4
N IL
N IL
2
N IL
N IL
5
1
2
N IL
1
N IL
N IL
N IL
N IL
4
N IL
1
N IL
3
1
N IL
1
N IL
N IL
4
N IL
N IL
2
2
N IL
5
1
2
2
1
N IL
N IL
N IL
N IL
4
N IL
1
N IL
3
3
N IL
1
N IL
N IL
4
N IL
N IL
2
2
N IL
5
1
2
2
1
N IL
N IL
4
4
4
4
1
N IL
3
3
3
4
4
N IL
4
4
2
2
2
N IL
5
1
1
1
1
N IL
N IL
4
4
4
4
3
N IL
3
3
3
4
4
N IL
4
4
5
2
2
N IL
5
1
1
1
1
N IL
(2) =
(3)
(4)
(5) =
F IG . 10.8 Squence des matrice D(k) et (k) calcules par lalgorithme F LOYD -WARSHALL pour le graphe de la
figure 10.6.
Chapitre 11
NP-compltude
Tous les algorithmes que nous avons vu jusqu prsent, taient des algorithmes en temps polynomial : sur des
entres de taille n, leur temps dexcution dans le pire cas tait en O(nk ) pour une certaine constante k. Do la
question : tous les problmes peuvent-ils tre rsolus en temps polynomial ?
Non, car certains ne peuvent pas tre rsolus (non dcidabilit de la terminaison) ;
Non, a priori, car il y a des problmes pour lesquels on ne connat que des algorithmes de cot exponentiel.
On aimerait donc savoir si un problme peut ou non tre rsolu par un algorithme polynomial : sil ne peut exister dalgorithme polynomial pour le rsoudre, il vaudra alors sans doute mieux dvelopper un algorithme dapproximation
(ou heuristique) polynomial quun algorithme de rsolution exact la complexit super-polynomiale.
La question de lexistence dun algorithme de rsolution de complexit polynomiale nous amne dfinir des
classes de complexit : intuitivement on aimerait avoir une classe des programmes que lon peut rsoudre en temps
polynomial, une classe de problme plus compliqus, et un moyen de dterminer quelle classe appartient un problme.
11.1
La classe P
11.1.1
Problmes abstraits
Dfinition
On dfinit un problme abstrait Q comme une relation binaire sur un ensemble I dinstances dun problme et
un ensemble S de solutions de ce problme.
Exemple : prenons le problme P LUS -C OURT-C HEMIN qui consiste trouver le plus court chemin entre deux
sommets dun graphe.
Une instance de ce problme est un triplet compos dun graphe et de deux sommets.
Une solution du problme est une squence de sommets du graphe (si la squence est vide, il nexiste pas de
chemin du graphe reliant les deux sommets).
Le problme lui-mme est la relation qui associe une instance donne une ou plusieurs solutions.
Restriction aux problmes de dcision
Dans le cadre de la thorie de la NP-compltude, nous nous restreindrons aux problmes de dcision, cest--dire
ceux dont la solution est soit vrai soit faux.
Exemple : prenons le problme C HEMIN qui rpond la question tant donn un graphe G, deux sommets u et v
et un entier positif k, existe-t-il dans G un chemin de u v de longueur au plus k ? .
Problmes doptimisation
De nombreux problmes abstraits ne sont pas des problmes de dcisions mais des problmes doptimisation.
Pour leur appliquer la thorie de la NP-compltude, le plus souvent on les reformulera sous la forme dun problme
83
84
CHAPITRE 11. NP-COMPLTUDE
doptimisation en imposant une borne sur la valeur optimiser, comme nous lavons fait en passant du problme
P LUS -C OURT-C HEMIN au problme C HEMIN.
11.1.2
Codage
Dfinition
Pour quun programme informatique puisse rsoudre un problme abstrait, il faut que ces instances soient reprsentes sous une forme comprhensible par le programme. On appelle codage dun ensemble S dobjets abstraits une
application e de S dans lensemble des chanes binaires (ou dans lensemble des chanes dun alphabet fini quelconque).
Exemple : le classique codage des entiers sous forme binaire...
Un algorithme informatique qui rsout un certain problme de dcision prend en fait en entre un codage dune
instance de ce problme. Un problme dont les instances forment lensemble des chanes binaires est appel problme
concret. On dit quun algorithme rsout un problme concret en O(T (n)) quand, sur une instance i du problme de
longueur n = |i|, lalgorithme est capable de produire la solution en au plus O(T (n)). Un problme concret est donc
rsoluble en temps polynomial sil existe un algorithme permettant de le rsoudre en temps O(nk ) pour une certaine
constante k.
Dfinition 14 (Classe de complexit P). La classe de complexit P est lensemble des problmes concrets de dcision
qui sont rsolubles en temps polynomial.
Limportance des codages
Pour quoi sembter avec des codages plutt que de dfinir directement la complexit dun problme abstrait ?
Parce que la complexit dpend du codage... Pour le voir, considrons un algorithme qui prend comme unique entre
un entier k, et dont le temps dexcution est en (k).
Si lentier k est fourni en unaire (son codage est alors une chane de k 1), le temps dexcution de lalgorithme
est en O(n) sur des entres de longueur n, et lalgorithme est de complexit polynomiale.
Si lentier k est fourni en binaire, la longueur du codage est alors de n = blog2 kc + 1, et le temps dexcution
de lalgorithme est en (k) = (2n ), et lalgorithme est de complexit superpolynomiale.
On ne peut donc pas parler de la complexit de la rsolution dun problme abstrait sans spcifier son codage.
Relativiser cette importance
Dfinition 15 (Fonction calculable en temps polynomial). Une fonction f : {0, 1} {0, 1} est calculable en
temps polynomial sil existe un algorithme polynomial qui, tant donn une entre x {0, 1} quelconque, produit le
rsultat f (x).
Deux codages e1 et e2 dfinis sur un mme ensemble S sont relis polynomialement sil existe deux fonctions
calculables en temps polynomial, f12 et f21 telles que pour tout s S on a f12 (e1 (s)) = e2 (s) et f21 (e2 (s)) = e1 (s).
Autrement dit, un codage peut tre calcul partir de lautre en temps polynomial, et rciproquement.
Thorme 9. Soit Q un problme de dcision abstrait et soient e1 et e2 deux codages (des instances de Q) relis
polynomialement. Alors, le problme concret dfini par Q et e1 appartient la classe P si et seulement si il en va de
mme du problme concret dfini par Q et e2 .
11.2
La classe NP
11.2.1
Algorithme de validation
Considrons le problme C HEMIN et une de ses instances (G, u, v, k). La question qui nous intresse est donc :
existe-t-il dans le graphe G un chemin reliant les sommets u et v dont la longueur est infrieure ou gale k ? Si lon se
donne galement un chemin p de u vers v, on peut facilement vrifier que la longueur de p est au plus gale k et, le
cas chant on peut voir p comme un certificat que le problme de dcision C HEMIN renvoie vrai sur cette instance.
85
11.3. NP-COMPLTUDE
Ici, la validation du fait que le problme concret de dcision C HEMIN renvoie vrai sur linstance (G, u, v, k), validation effectue partir du certificat p, prend autant de temps que la rsolution du problme partir de rien. Ce nest
pas toujours le cas.
Exemple : il est trivial de vrifier quun chemin est un cycle hamiltonien (cycle simple contenant tous les sommets)
dun graphe donn alors que lon ne sait rsoudre ce problme quen temps super polynomial.
Dfinition 16 (Algorithme de validation). Soit un problme concret de dcision Q. Un algorithme de validation
pour Q est un algorithme de dcision A deux arguments, o un argument est une instance x du problme, et o
lautre argument est un certificat y. Lalgorithme A valide lentre x si et seulement si il existe un certificat y tel que
A(x, y) = vrai. Bien videmment, lalgorithme A ne doit valider que les instances x de Q pour lesquelles Q(x) est vrai.
Si Q(x) = faux, il ne doit pas y avoir de certificat validant x.
Exemple : dans le problme du cycle hamiltonien, le certificat est la liste des sommets du cycle hamiltonien. Si un
graphe est hamiltonien, le cycle lui-mme offre toute linformation ncessaire pour le prouver. Rciproquement, si un
graphe nest pas hamiltonien, il nexiste aucune liste de sommets capable de faire croire lalgorithme de validation
que le graphe est hamiltonien : lalgorithme de validation se rend bien compte que le cycle dcrit par la liste des
sommets nest pas un cycle du graphe tudi.
Remarque : dans limmense majorit des cas le certificat sera une solution du problme considr...
11.2.2
La classe de complexit NP
Dfinition 17 (Classe de complexit NP). La classe de complexit NP est lensemble des problmes concrets de
dcision Q pour lesquels il existe un algorithme polynomial de validation A.
c 0 telle que pour tout x instance de Q :
Q(x) = vrai y certificat, |y| = O(|x|c ), A(x, y) = vrai
Remarques
Daprs cette dfinition et ce qui prcde, le problme C YCLE -H AMILTONIEN appartient NP.
P NP (soit Q un problme de la classe P, il existe donc un algorithme polynomial qui rsout Q, on le convertit
facilement en algorithme de validation qui ignore le certificat).
P = NP ? On nen sait rien. La majorit des chercheurs pense que P 6= NP, et donc que P ( NP.
La classe de complexit P est la classe des problmes qui peuvent tre rsolus rapidement. La classe de complexit NP est celle des problmes pour lesquels une solution peut tre rapidement valide (vrifie). Intuitivement, P ( NP signifierait quil existe des algorithmes difficiles rsoudre mais dont une solution peut tre
facilement vrifie...
11.3 NP-compltude
Une des raisons qui laissent penser que P 6= NP est lexistence de la classe des problmes NP-complets : si un
seul problme NP-complet peut tre rsolu en temps polynomial, alors tous les problmes de NP peuvent tre rsolus
en temps polynomial et P = NP. Mais aucun algorithme polynomial na jamais t dcouvert pour aucun problme
NP-complet. Les problmes NP-complets sont, dans un certain sens, les problmes les plus difficiles de NP.
11.3.1
Rductibilit
Nous avons besoin de pouvoir comparer la difficult de problmes. Intuitivement, un problme Q1 peut tre ramen
un problme Q2 si une instance quelconque x de Q1 peut tre facilement reformule comme une certaine instance
y de Q2 . Dans ce cas, la rsolution du problme Q2 (y) nous fournira la solution du problme Q1 (x) et le problme Q1
nest, dans un certain sens, pas plus difficile rsoudre que le problme Q2 .
86
Exemple trivial : le problme de la rsolution dquations linaires une inconnue (a x + b = 0) peut tre ramene
la rsolution dquations quadratiques (a x2 + b x + c = 0).
Dfinition 18 (Problme rductible un autre en temps polynomial). Soient Q1 et Q2 deux problmes concrets.
Q1 est rductible en temps polynomial Q2 (ce que lon note Q1 P Q2 ) sil existe une fonction calculable en temps
polynomial f : {0, 1} {0, 1} telle que pour tout x {0, 1} :
Q1 (x) = vrai
si et seulement si
Q2 ( f (x)) = vrai.
Exemple non trivial :

1. Problme Q1 : problme de lexistence dun cycle Hamiltonien (cycle simple qui comprend tous les sommets)
dans un graphe donn G1 .
2. Problme Q2 : tant donn un graphe G2 de villes valu des distances inter-villes, existe-t-il un cycle (pas
forcment simple) passant par toutes les villes, et de longueur infrieure une valeur fixe M ?
3. Rduction de Q1 Q2 :
On cre un graphe G2 de villes contenant autant de villes que G1 de sommets. On associe chaque sommet de
G1 une ville de G2 .
Si deux sommets de G1 sont relis par une arte, on relie les deux villes correspondantes de G2 par une arte
value de la distance interville 1 , et sinon value par la distance interville 2 .
4. On excute lalgorithme rsolvant Q2 sur G2 avec M = n, le nombre de sommets de G1 . Sil existe un tel cycle...
il est hamiltonien ! Et si G1 admet un cycle hamiltonien, G2 admet un cycle tel que recherch.
5. G2 contient autant de villes que G1 de sommets, et le nombre dartes de G2 est gal au nombre de paires de
sommets de G1 : n(n1)
2 . La rduction est linaire en la taille de G2 et est donc bien polynomiale en la taille de
G1 .
11.3.2
Dfinition de la NP-compltude
Les rductions en temps polynomial fournissent un moyen formel de montrer quun problme est au moins aussi
difficile quun autre, un facteur polynomial prs : si Q1 P Q2 , alors Q1 nest pas plus difficile rsoudre un facteur
polynomial prs, que Q2 . Les rductions nous permettent de dfinir lensemble des problmes NP-complets, qui sont
les problmes les plus difficiles de NP.
Dfinition 19 (Problme NP-complet). Un problme Q est NP-complet si
1. Q NP.
2. Q0 NP, Q0 P Q.
On note NPC la classe des problmes NP-complets.
Un problme concret qui vrifie la proprit 2 mais pas ncessairement la proprit 1 est dit NP-difficile.
Thorme 10. Si un problme de NP est rsoluble en temps polynomial, alors P = NP. De faon quivalente, si un
problme quelconque de NP nest pas rsoluble en temps polynomial, alors aucun problme NP-complet ne peut se
rsoudre en temps polynomial.
11.3.3
Exemples de problmes NP-complets
Il existe des problmes NP-complets :

SAT : soit une formule boolenne compose de variables x1 , ..., xn et de connecteurs (et, ou, non, implication,
quivalence) et de parenthses ; existe-t-il une affectation des variables x1 , ..., xn pour laquelle la formule soit
vraie ?
Premier problme dont la NP-compltude ait t dmontre, par Cook en 1971.
3-SAT : mme problme que SAT, la formule tant sous forme normale conjonctive trois littraux, cest--dire
de la forme : ETiI (ti,1 ou ti,2 ou ti,3 ) avec i, j, k, ti, j = xk ou ti, j = xk .
PARTITION : peut-on diviser un ensemble dentier en deux ensembles de mme somme ?
87
11.3. NP-COMPLTUDE
C LIQUE : un graphe donn contient-il une clique (un sous-graphe complet) de taille k ?
C YCLE -H AMILTONIEN.
VOYAGEUR - DE -C OMMERCE : le voyageur de commerce veut faire la tourne dun ensemble de villes (cycle
hamiltonien) la plus courte possible.
3-C OLORIAGE D UN GRAPHE : peut-on colorier laide de trois couleurs les sommets dun graphe de sorte que
deux sommets adjacents aient des couleurs diffrentes ?
11.3.4
Preuves de NP-compltude
Comment dmontrer quun problme est NP-complet ?

Thorme 11. Si Q1 est un problme tel que Q2 P Q1 pour un certain problme Q2 NPC, alors Q1 est NP-difficile.
De plus, si Q1 NP, alors Q1 NPC.
Commentaire : la premire assertion montre que Q1 est polynomialement plus difficile quun problme polynomialement plus difficile que tous les problmes de NP.
Mthode pour montrer la NP-compltude dun problme Q1
1. Prouver que Q1 NP.
2. Choisir un problme NP-complet Q2 .
3. Dcrire un algorithme polynomial capable de calculer une fonction f faisant correspondre toute instance de Q2
une instance de Q1 .
4. Dmontrer que la fonction f satisfait la proprit :
Q2 (x) = vrai
si et seulement si
Q1 ( f (x)) = vrai.
5. Dmontrer que lalgorithme calculant f sexcute en temps polynomial.

Preuve de la NP-compltude de Cycle-Ham
1. On a vu la section 11.2.1 un algorithme polynomial de validation de C YCLE -H AM. Par consquent, C YCLE H AM NP.
2. On a choisi le problme de lexistence dun cycle passant par tous les sommets et de taille borne (on suppose
que lon sait que ce problme est NP-complet).
3. On a vu la section 11.3.1 un algorithme de rduction.
4. On a montr la section 11.3.1 la correction de la rduction.
5. On a montr la section 11.3.1 que lalgorithme de rduction tait polynomial.
Donc le problme C YCLE -H AM est NP-complet.
88
Chapitre 12
Heuristiques
Si le problme rsoudre est NP-complet, plutt que dlaborer un algorithme de complexit super-polynomiale,
on peut avoir intrt recourir un algorithme dapproximation ou heuristique cest--dire un algorithme
qui ne construira que des solutions presque optimales. On recherchera bien videmment des algorithmes dapproximations de complexit polynomiale .
Bornes de performances
Supposons que lon cherche rsoudre un problme doptimisation dans lequel chaque solution potentielle a un
cot positif et que lon cherche trouver une solution de cot minimal. Un algorithme dapproximation a une borne
(n) si pour toute entre de taille n, le cot dune solution produite par lalgorithme est au plus (n) fois le cot C
dune solution optimale :
C
(n),
C
autrement dit, un algorithme dapproximation a une borne (n) si pour toute entre de taille n, une solution produite
par lalgorithme est au pire (n) fois plus coteuse quune solution optimale. Un algorithme dapproximation qui
admet une borne est appel heuristique garantie.
On peut, de mme dfinir lerreur relative dun algorithme dapproximation par :
|C C |
.
C
Un algorithme dapproximation a une borne derreur relative gale (n) si et seulement si :
|C C |
(n).
C
Un schma dapproximation est un algorithme dapproximation qui prend en entre, en plus dune instance du
problme, une valeur > 0 et qui renvoie une solution approche avec une borne derreur relative gale . Il sagit
donc dune heuristique dont on peut contraindre la prcision.
12.1
Le problme de la couverture de sommet
Soit un graphe non orient G = (S, A). Une couverture de sommet est un sous ensemble S0 de S (S0 S) tel que si
(u, v) est une arte de G, alors soit u S0 , soit v S0 (soit u et v appartiennent tous deux S0 ). La taille dune couverture
est le nombre de sommets quelle contient.
Le problme de la couverture de sommet consiste trouver une couverture de sommet de taille minimale. Ce
problme est NP-difficile (le problme de dcision associ est NP-complet).
89
90
12.1.1
CHAPITRE 12. HEURISTIQUES
Heuristique
Bien que le problme de la couverture de sommet soit compliqu, on peut facilement concevoir une heuristique
garantie pour le rsoudre :
C OUVERTURE -S OMMET-A PPROCHE(G)
C 0/
A0 A
tant que A0 6= 0/ faire
soit (u, v) une arte arbitraire de A0
C C {u, v}
supprimer de A0 toutes les artes incidentes soit u soit v
renvoyer C
12.1.2
Exemple dutilisation
b
b)
a)
c)
d)
f
e)
f)
F IG . 12.1 Exemple dutilisation de lalgorithme C OUVERTURE -S OMMET-A PPROCHE, les sommets sur fond blanc
tant ceux appartenant la couverture : a) le graphe G de dpart ; b) larte (b, c), en gras, est la premire choisie par
C OUVERTURE -S OMMET-A PPROCHE, les sommets b et c sont rajouts la couverture ; c) larte (e, f) est choisie
et les sommets e et f sont rajouts la couverture ; d) larte (d, g) est choisie et les sommets d et g sont rajouts la
couverture ; e) la couverture produite contient donc les sommets b, c, d, e, f et g ; f) la couverture optimale ne contient
que trois sommets : b, d et e.
12.1.3
Garantie de performances
Thorme 12. Lheuristique C OUVERTURE -S OMMET-A PPROCHE possde une borne de 2.
12.2. LE PROBLME DU VOYAGEUR DE COMMERCE
91
Dmonstration
Soit E lensemble des artes qui ont t choisies la ligne 4 de lheuristique. Par construction, deux artes quelconque de E ne peuvent pas avoir un sommet en commun. Donc chaque excution de la ligne 5 de lheuristique ajoute
deux nouveaux sommets C et |C| = 2 |E|. Soit C une couverture de sommet de taille minimale. Comme deux
artes de E ne peuvent avoir de sommets en commun, un sommet de C est incident au plus une arte de E. Par
ailleurs, par dfinition dune couverture de sommets, C doit contenir au moins une des deux extrmits de chacune
des artes de E. Donc |E| |C |. Do, |C| 2 |C |.
12.2 Le problme du voyageur de commerce

Nous considrons ici aussi un graphe non orient G = (S, A). Mais ici le graphe est complet : chaque paire de
sommets est relie par une arte. On a un poids positif ou nul w(u, v) associ chaque arte (u, v) du graphe. Le
problme est ici de trouver un cycle hamiltonien (une tourne) de poids minimal.
Nous restreignons ici le problme en supposant que la fonction de poids w vrifie lingalit triangulaire : soient
u, v et w trois sommets quelconques, alors :
w(u, w) w(u, v) + w(v, w).
T OURNE -A PPROCHE(G, w)
Choisir arbitrairement un sommet r de G qui servira de racine
Construire un arbre couvrant minimal T pour G partir de la racine r
Soit L la liste des sommets visits lors dun parcours prfixe de T
renvoyer le cycle hamiltonien H qui visite les sommets dans lordre de L.
Un arbre couvrant minimal est un arbre qui contient tous les sommets du graphe (= couvrant) et dont la somme
des poids des artes est minimale.
Un parcours prfixe visite tous les sommets dun arbre. Larbre T tant ici couvrant, la liste L contient bien tous
les sommets du graphe et G est bien dfini. Le parcours est prfixe : un nud est donc visit avant que ses fils ne le
soient.
La complexit de cet algorithme est en (S2 ) car le graphe est complet (cest la complexit de la construction dun
arbre couvrant minimal dans ce cas).
12.2.1
Exemple dutilisation
Voir la figure 12.2.
12.2.2
Garantie de performances
Thorme 13. T OURNE -A PPROCHE est un algorithme dapproximation ayant une borne gale deux pour le
problme du voyageur de commerce avec ingalit triangulaire.
Dmonstration
Nous devons donc montrer que, si H est une tourne optimale, on a w(H) 2w(H ).
En supprimant certaines artes de H (nimporte laquelle dans notre exemple), on peut toujours obtenir un arbre
couvrant T 0 . Do w(T 0 ) w(H ). Comme T est, par dfinition, un arbre couvrant de poids minimal, on a w(T )
w(T 0 ) w(H ).
Un parcours complet de T liste les sommets ds quils sont visits pour la premire fois et galement quand ils
sont nouveau traverss aprs la visite dun sous-arbre. Soit W ce parcours. Le parcours complet dans notre exemple
a pour rsultat la liste :
a, b, c, b, h, b, a, d, e, f , e, g, e, d, a.
92
CHAPITRE 12. HEURISTIQUES
e
b
a
e
e
g
h
a)
c)
e
b
h
b)
e
g
c
h
h
d)
e)
F IG . 12.2 Exemple dutilisation de lalgorithme T OURNE -A PPROCHE : a) lensemble des sommets auxquels on
fait correspondre les sommets dune grille, le poids dune arte tant gal la distance euclidienne des deux sommets
quelle relie ; b) arbre couvrant de poids minimal et de racine a ; c) parcours de larbre partant de a ; un parcours
complet visite les sommets dans lordre : a, b, c, b, h, b, a, d, e, f, e, g, e, d et a ; un parcours prfixe visite les
sommets dans lordre : a, b, c, h, d, e, f et g ; d) tourne des sommets obtenue partir du parcours prfixe et de cot
environ 19,074 ; e) tourne optimale de cot environ 14,715.
Un parcours complet traverse toutes les artes de T exactement deux fois. Par consquent :
w(W ) = 2w(T ) 2w(H ).
W nest pas une tourne, et notre dmonstration nest pas termine ! Grce lingalit triangulaire, on peut
supprimer de W la visite dun sommet quelconque sans augmenter le poids : si un sommet v est supprim de W entre
les visites u et w, la nouvelle liste va directement de u w (avec un poids w(u, w) w(u, v) + w(v, w)). En appliquant
plusieurs fois ce rsultat, on peut supprimer de W toutes les visites chaque sommet sauf la premire, et sauf la
dernire visite du premier sommet (la racine). Dans notre exemple, on se retrouve avec la liste rduite :
a, b, c, h, d, e, f , g, a.
Cette liste est correspond exactement au parcours H et H est donc obtenu en supprimant (en utilisant lingalit
triangulaire) des sommets du parcours complet W . Par consquent :
w(H) w(W ) et w(H) 2 w(H ).
Bibliographie
[1] Robert Cori and Jean-Jacques Lvy.
Algorithmes et programmation.
http://www.enseignement.
polytechnique.fr/profs/informatique/Jean-Jacque%s.Levy/poly/. Cours de lcole Polytechnique.
[2] Thomas Cormen, Charles Leiserson, and Ronald Rivest. Introduction lalgorithmique. Dunod, 1994.
[3] Donald E. Knuth. Seminumerical Algorithms, volume 2 of The Art of Computer Programming. Addison Wesley,
1969.
[4] Donald E. Knuth. Sorting and searching, volume 3 of The Art of Computer Programming. Addison Wesley, 1973.
93

Algorithmique PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Algorithmique PDF

Transféré par

Droits d'auteur :

Formats disponibles

Algorithmique avance

Table des matires

Complexit et optimalit ; premier algorithme de tri

La rcursivit et le paradigme diviser pour rgner

TABLE DES MATIRES

Rsolution des rcurrences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Structures de donnes lmentaires

TABLE DES MATIRES

Arbres de recherche et arbres de recherche quilibrs

10 Plus courts chemins

Table des figures

Exemple dutilisation de lalgorithme T RI -I NSERTION. . . . . . . . . . . . . . . . . . . . . . . . . .

Mthode de rsolution du jeu des tours de Hano. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Exemple de manipulation de pile. . . . . . . . . . . . . . . . . . . .

Illutration de lalgorithme O RDONNER -C HANE D E M ATRICES. . . . . . . . . . . . . . . . . . . . .

Exemple de graphe orient. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

TABLE DES FIGURES

Deux arbres binaires de recherche contenant les mmes valeurs. . . . . . . . . . . . . . . .

Algorithme de Dijkstra pour le calcul des plus courts chemins. . . . . . . . . . . . . .

12.1 Exemple dutilisation de lalgorithme C OUVERTURE -S OMMET-A PPROCHE. . . . . . . . . . . . . .

Diffrences entre algorithmes et programmes

yi = yi1 y1 , i [2, n]. Rsultat : yn = xn . Cot : m 1 = n 1 multiplications.

4. Nous partons de x et nous obtenons successivement :

criture binaire de n : n = i=0 ai 2i .

montrer que y1 = xi=0 ai 2 = xn ...

1.2. MOTIVATION : CALCUL DE X N

1.2.4 Algorithme des facteurs

Peut-on faire mieux ?

Le k + 1e niveau de larbre est dfini comme suit :

F IG . 1.1 Arbre de puissances (minimisant le nombre

F IG . 1.2 Schma de calcul pour n = 23.

K NUTH [3] consacre prs de 26 pages ce problme...

Complexit et optimalit ; premier

o : n = o(n), log(n) = o(n), n = o(n2 ), log(n) = o( n).

n = O(n), log(n) = O(n),

CHAPITRE 2. COMPLEXIT ET OPTIMALIT ; PREMIER ALGORITHME DE TRI

En pratique, nous ne nous intresserons qu la complexit au pire et la complexit en moyenne.

Illustration : cas du tri par insertion

Entre : une squence de n nombres, a1 , ..., an .

Principe du tri par insertion

On retire un nombre de la squence dentre

2.2. ILLUSTRATION : CAS DU TRI PAR INSERTION

CHAPITRE 2. COMPLEXIT ET OPTIMALIT ; PREMIER ALGORITHME DE TRI

Revenons la fonction puissance x 7 xn . Cette fonction peut tre dfinie rcursivement :

CHAPITRE 3. LA RCURSIVIT ET LE PARADIGME DIVISER POUR RGNER

La fonction dAckermann est dfinie comme suit :

A(m 1, A(m, n 1))

Principe et dangers de la rcursivit

Non dcidabilit de la terminaison

Importance de lordre des appels rcursifs

Fonction qui affiche les entiers par ordre dcroissant, de n jusqu 1 :

CHAPITRE 3. LA RCURSIVIT ET LE PARADIGME DIVISER POUR RGNER

Exemple dalgorithme rcursif : les tours de Hano

3.2.1 Rcursivit terminale

CHAPITRE 3. LA RCURSIVIT ET LE PARADIGME DIVISER POUR RGNER

Rcursivit non terminale

3.3. DIVISER POUR RGNER

F IG . 3.2 Exemple dexcution de lalgorithme drcursiv.

3.3 Diviser pour rgner

CHAPITRE 3. LA RCURSIVIT ET LE PARADIGME DIVISER POUR RGNER

Premier exemple : multiplication nave de matrices

Nous nous intressons ici la multiplication de matrices carrs de taille n.

Analyse des algorithmes diviser pour rgner