Vous êtes sur la page 1sur 159

Algorithmique - Cours et Travaux Dirigs

Ecole Normale Suprieure de Lyon


Rdaction
Etudiants-scribes, MIM 2003 et 2004
Cours
Yves Robert
Travaux Dirigs
Yves Caniou et Eric Thierry
2003-2004-2005
2
Table des matires
1 Introduction : calcul de x
n
11
1.1 nonc du problme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.2 Algorithme naf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.3 Mthode binaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4 Mthode des facteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.5 Arbre de Knuth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.6 Rsultats sur la complexit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.7 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.8 Rfrences bibliographiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2 Diviser pour rgner 19
2.1 Algorithme de Strassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.2 Produit de deux polynmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3 Master theorem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.4 Rsolution des rcurrences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.4.1 Rsolution des rcurrences homognes . . . . . . . . . . . . . . . . . . . . 23
2.4.2 Rsolution des rcurrences avec second membre . . . . . . . . . . . . . . . 23
2.5 Multiplication et inversion de matrices . . . . . . . . . . . . . . . . . . . . . . . . 24
2.6 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.7 Rfrences bibliographiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3 Programmation dynamique 35
3.1 Pices de Monnaies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.2 Le problme du sac dos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.2.1 En glouton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.2.2 Par programmation dynamique . . . . . . . . . . . . . . . . . . . . . . . . 36
3.3 Quelques exemples de programmation dynamique . . . . . . . . . . . . . . . . . . 37
3.3.1 Chanes de matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.3.2 Plus longue sous-suite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.3.3 Location de skis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.5 Rfrences bibliographiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
4 Algorithmes gloutons 51
4.1 Exemple du gymnase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
4.2 Coloriage dun graphe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4.2.1 Algorithme glouton 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.2.2 Algorithme glouton 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.2.3 Graphe dintervalles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3
4.2.4 Algorithme de Brelaz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.3 Thorie des matrodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.3.1 Matrodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.3.2 Algorithme glouton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.4 Ordonnancement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.6 Rfrences bibliographiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
5 Tri 63
5.1 Tri rapide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
5.1.1 Cot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
5.1.2 Mdiane en temps linaire . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
5.2 Tri fusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
5.3 Tri par tas : Heapsort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
5.3.1 Dnitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
5.3.2 Tri par tas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
5.3.3 Insertion dun nouvel lment . . . . . . . . . . . . . . . . . . . . . . . . . 66
5.3.4 Suppression dun lment du tas . . . . . . . . . . . . . . . . . . . . . . . 66
5.4 Complexit du tri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5.4.1 Les grands thormes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5.4.2 Dmonstration des thormes . . . . . . . . . . . . . . . . . . . . . . . . . 67
5.4.3 Peut-on atteindre la borne ? . . . . . . . . . . . . . . . . . . . . . . . . . . 69
5.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.6 Rfrences bibliographiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
6 Graphes 87
6.1 Dnitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
6.2 Arbres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
6.2.1 Caractrisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
6.2.2 Parcours darbres binaires . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
6.2.3 Arbres binaires de recherche . . . . . . . . . . . . . . . . . . . . . . . . . . 91
6.3 Structures de donnes pour les graphes . . . . . . . . . . . . . . . . . . . . . . . . 93
6.4 Accessibilit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
6.4.1 Rappels sur les relations binaires . . . . . . . . . . . . . . . . . . . . . . . 97
6.4.2 Chemins dans les graphes . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
6.4.3 Fermeture transitive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
6.5 Plus courts chemins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
6.5.1 Dnitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
6.5.2 Prsentation des plus courts chemins . . . . . . . . . . . . . . . . . . . . . 101
6.5.3 Avec des poids positifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
6.5.4 Chemins algbriques dans les semi-anneaux . . . . . . . . . . . . . . . . . 102
6.5.5 Algorithme de Dijkstra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
6.6 Parcours en largeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
6.7 Parcours en profondeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
6.7.1 Premire version . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
6.7.2 Analyse ne du parcours en profondeur . . . . . . . . . . . . . . . . . . . 108
6.8 Tri topologique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
6.9 Forte connexit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
6.10 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
6.11 Rfrences bibliographiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
4
7 Tables de hachage 119
7.1 Recherche en table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
7.2 Tables de hachage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
7.3 Collisions spares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
7.4 Adressage ouvert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
7.5 Rfrences bibliographiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
8 Analyse amortie 123
8.1 Compteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
8.1.1 Mthode des acomptes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
8.1.2 Mthode du potentiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
8.2 Malloc primaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
8.2.1 Mthode globale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
8.2.2 Mthode des acomptes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
8.2.3 Mthode du potentiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
8.3 Insertion ET suppression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
8.4 Gestion des partitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
8.4.1 Reprsentation en listes chanes . . . . . . . . . . . . . . . . . . . . . . . 125
8.4.2 Reprsentation en arbres . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
8.5 Rfrences bibliographiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
9 NP-Compltude 127
9.1 P versus NP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
9.2 3-SAT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
9.3 Clique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
9.4 Couverture par les sommets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
9.5 Circuit hamiltonien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
9.6 Coloration de graphes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
9.6.1 COLOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
9.6.2 3-COLOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
9.6.3 3-COLOR-PLAN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
9.7 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
9.8 Rfrences bibliographiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
10 Algorithmes dapproximation 145
10.1 Dnition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
10.2 Vertex cover . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
10.2.1 Version classique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
10.2.2 Version pondre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
10.3 Voyageur de commerce : TSP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
10.3.1 Dnition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
10.3.2 Inapproximabilit de TSP : . . . . . . . . . . . . . . . . . . . . . . . . . . 147
10.3.3 2-approximation dans le cas o c vrie lingalit triangulaire . . . . . . . 147
10.4 Bin Packing : BP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
10.4.1 Dnition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
10.4.2 Next Fit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
10.4.3 Dec First Fit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
10.5 2-Partition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
10.5.1 NP-compltude au sens faible et au sens fort . . . . . . . . . . . . . . . . 150
10.5.2 Approximation gloutonnes . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
5
10.5.3 Une (1 +)-approximation . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
10.5.4 FPTAS pour 2-Partition . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
10.6 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
10.7 Rfrences bibliographiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
6
Prface
Ce polycopi rassemble les cours et travaux dirigs (avec corrigs) du module Algorithmique
de lENS Lyon. A lorigine prvu pour la premire anne du Magistre dInformatique, le module
sintgre dsormais dans la troisime anne de la Licence dInformatique. Et dire que personne
ne sest rendu compte du changement !
Cela fait peine dix ans que jenseigne ce cours. A dfaut de changer le contenu (pour
faire quoi dautre ?) ou dutiliser autre chose que le tableau et la craie (idem?), je change les
irrsistibles traits dhumour qui font tout le charme de ces sances du Mercredi (lhoraire ne
change pas non plus). Et juse toute une batterie de TD-men and women, lesquels ont apport
leur contribution au l des ans, construisant ou amliorant des sances de travaux dirigs. Je
les remercie tous sincrement, par ordre dapparition : Odile Millet-Botta, Tanguy Risset, Alain
Darte, Bruno Durand, Frdric Vivien, Jean-Christophe Dubacq, Olivier Bodini, Daniel Hir-
schko, Matthieu Exbrayat, Natacha Portier, Emmanuel Hyon, Eric Thierry, Michel Morvan et
Yves Caniou.
Sans aucune pression ou presque, Yves Caniou et Eric Thierry ont russi se motiver pour
rassembler les TD. Lanne prcdente, javais rassembl les cours. Enn, quand on dit rassem-
bler, cest surtout les gentils tudiants-scribes qui rassemblent, en tapotant de leurs doigts agiles
la quintessence de notre enseignement ingalable.
Ce polycopi est le concurrent le plus srieux du Cormen dans le monde, ou du moins dans
le septime arrondissement de Lyon ! Mais renonant de fabuleux droits dauteur, lquipe
pdagogique (cest nous) a dcid de mettre cet ouvrage la libre disposition des nombreux
tudiants assois de savoir (cest vous). Enjoy ! Et merci de signaler erreurs et omissions par
courrier lectronique Yves.Robert@ens-lyon.fr.
Lyon, Mai 2005
Yves Robert
Biblio
Voici quelques pointeurs bibliographiques (voir aussi les rfrences donnes la n de chaque
chapitre) :
Introduction to Algorithms de T. H. Cormen, C. E. Leiserson et R. L. Rivest [2]. Lou-
vrage de rfrence par excellence, acheter et conserver toute sa vie dinformaticien. Il se
murmure quune deuxime dition est parue, avec un auteur de plus. Et une traduction
franaise.
Computers and Intractability, a Guide to the Theory of NP-Completeness de M. R.
Garey et D. S. Johnson [5]. Essentiellement pour son introduction la NP-compltude au
sens fort, et quelques jolies rductions. On revient toujours son catalogue de problmes
NP-complets.
7
The art of Computer Programming , les trois tomes de Knuth [6], et bientt quatre, pour
leurs exercices incroyables
8
Sinon, jaime bien :
Types de Donnes et Algorithmes, le livre de Froidevaux, Gaudel et Soria [3], pour lanalyse
ne des problmes de tri
le NP-compendium, maintenu sur le Web (http://www.nada.kth.se/~viggo/problemlist/
compendium.html), pour les rsultats dapproximation. Le livre qui correspond, Complexity
and Approximation, de Ausiello et al. [1] est vraiment trs complet, avec une bonne intro-
duction aux schmas dapproximation.
Algorithms and Complexity, le livre de Wilf [12], dont la premire dition, puise, est
disponible librement lurl http://www.cis.upenn.edu/~wilf/. Une jolie introduction
la NP-compltude, avec une preuve concise du thorme de Cook, plein dalgorithmes, de
lhumour, dans un chier .pdf tlcharger absolument
Compared to what ? : an introduction to the analysis of algorithms, le livre de Rawlins [8],
qui contient une mine dexercices originaux
Introduction to Graph Theory, de West [11], mon livre prfr de graphes
Enn, deux livres plus diciles, rserver aux plus aventureux : celui de Kozen [7], The design
and analysis of algorithms, contient les notes de cours et exercices (certains corrigs) dun cours
de niveau avanc donn Cornell, et celui de Vazirani [10], Approximation algorithms, dont le
titre rsume bien le contenu.
9
10
Chapitre 1
Introduction : calcul de x
n
1.1 nonc du problme
On tudie le problme du calcul de x
n
, tant donns x et n (n tant un entier positif).
Soulignons que x nest pas ncessairement un nombre, il peut sagir dune matrice ou dun
polynme plusieurs indtermines : si la multiplication a un sens, la division nen a pas !
On pose y
0
= x, et on utilise la rgle du jeu suivante : si jai dj calcul y
1
, y
2
, . . . , y
i1
,
je peux calculer y
i
comme produit de deux rsultats prcdents arbitraires :
y
i
= y
j
y
k
, avec 0 j, k i 1
Le but est datteindre x
n
le plus vite possible, i.e. de trouver
Opt(n) = min{i/y
i
= x
n
}.
1.2 Algorithme naf
Considrons lalgorithme naf suivant :
y
i
= y
0
y
i1
On a y
n1
= x
n
, le cot est donc de n 1.
1.3 Mthode binaire
On trouve facilement un algorithme plus ecace :
x
n
=
_
x
n/2
x
n/2
si n est pair,
x
n/2
x
n/2
x si n est impair.
On peut aussi formuler lalgorithme de la faon suivante. On crit n en criture binaire. Puis
on remplace chaque 1 par SX et chaque 0 par S, et on enlve le premier SX (celui qui est
gauche). Le mot obtenu donne un faon de calculer x
n
, en traduisant S par lopration mettre
au carr (squaring), et X par lopration multiplier par x. Par exemple, pour n = 23, la chane
obtenue est SX S SX SX SX, en enlevant le premier SX, on obtient SSXSXSX. On calcule donc
dans lordre x
2
, x
4
, x
5
, x
10
, x
11
, x
22
, et x
23
.
La correction de lalgorithme se justie facilement partir des proprits du systme binaire.
Le cot est de :
log n| +(n) 1,
11
o (n) reprsente le nombre de 1 dans lcriture binaire de n. Bien sr, comme dans tout
ouvrage dinformatique qui se respecte, les logarithmes sont en base 2.
Cette mthode binaire nest pas optimale : par exemple avec n = 15, on obtient la chane
SXSXSX, do 6 multiplication alors que en remarquant que 15 = 3 5, on a besoin de 2
multiplications pour trouver y = x
3
(y = (x x) x) puis de 3 autres pour calculer x
15
= y
5
(on
applique la mthode binaire : y
2
, y
4
, y
5
).
1.4 Mthode des facteurs
La mthode des facteurs est base sur la factorisation de n :
x
n
=
_
(x
p
)
q
si p est le plus petit facteur premier de n,
x
n1
x sin est premier.
Remarque : Avec les puissances de 2, cette mthode est identique la mthode binaire.
Remarque : Cette mthode nest pas optimale, par exemple pour n = 33 on a 7 multiplications
avec la mthode des facteurs et seulement 6 avec la mthode binaire.
Remarque : Il existe une innit de nombres pour lesquels la mthode des facteurs est
meilleure que la mthode binaire (prendre n = 15 2
k
), et rciproquement (prendre n = 33 2
k
).
Il faut souligner que le cot de la recherche de la dcomposition de n en facteurs premiers
nest pas pris en compte dans notre formulation. Cest pourtant ncessaire pour quantier cor-
rectement le cot de la mthode des facteurs. Le problme est quon ne sait pas, ce jour,
trouver la dcomposition en temps polynomial en n.
1.5 Arbre de Knuth
Une autre mthode consiste utiliser larbre de Knuth, reprsent Figure 1.1. Le chemin
menant de la racine de larbre n indique une squence dexposants permettant de calculer x
n
de faon ecace.
1
2
3
5
7
14
19 21 28
10
11
22
13
23 26
15
25 30
20
40
6
9
18
27 36
12
24
48
4
8
16
17
33 34
32
64
Fig. 1.1 Les sept premiers niveaux de larbre de Knuth.
12
Construction de larbre Le (k + 1)-me niveau de larbre est dni partir des k premiers
niveaux de la faon suivante : prendre chaque nud n du k-me niveau, de gauche droite, et
les relier avec les nuds
n + 1, n +a
1
, n +a
2
, . . . , n +a
k1
= 2n
(dans cet ordre), o 1, a
1
, . . . , a
k1
= n reprsente le chemin de la racine n. On najoutera pas
un nud si celui ci est dj prsent dans larbre.
Voici quelques statistiques dues Knuth : les plus petits nombres pour lesquels la mthode
nest pas optimale sont n = 77, 154, 233. Le plus petit n pour lequel la mthode de larbre est
suprieure la fois la mthode binaire et celle des facteurs est n = 23. Le plus petit n pour
lequel la mthode de larbre est moins bonne que celle des facteurs est n = 19879 = 103 193 ;
de tels cas sont rares : pour n 100000, larbre bat les facteurs 88803 fois, fait match nul 11191
fois et perd seulement 6 fois.
1.6 Rsultats sur la complexit
Thorme 1. Opt(n) log n|
Preuve. Soit un algorithme permettant de calculer les puissances de x, avec pour tout i, y
i
=
x
(i)
. Montrons par rcurrence que (i) 2
i
. Pour la base, on a bien y
0
= x do 1 2
0
= 1.
Soit i un entier, il existe j et k (j, k < k) tels que y
i
= y
j
y
k
. On a (i) = (j) + (k), par
lhypothse dinduction, (j) 2
j
2
i1
et de mme (k) 2
i1
. On en dduit donc que
(i) 2
i1
+ 2
i1
= 2
i
.
Intuitivement, la preuve exprime quon ne peut pas faire mieux que doubler lexposant obtenu
chaque tape de lalgorithme.
Grce au thorme prcdent, et ltude de la mthode binaire, dont le nombre dtapes
est infrieur 2 log n, on a le rsultat suivant :
1 lim
n
Opt(n)
log n
2.
Thorme 2. lim
n
Opt(n)
log n
= 1
Preuve. Lide est damliorer la mthode binaire en appliquant cette mthode en base m.
Posons m = 2
k
, o k sera dtermin plus tard, et crivons n en base m :
n =
0
m
t
+
1
m
t1
+ +
t
,
o chaque
i
est un chire en base m, donc compris entre 0 et m1. Puis on calcule tous les
x
d
, 1 d m1) par la mthode nave, ce qui requiert m2 multiplications. En fait, on na
pas forcment besoin de toutes ces valeurs, seulement des x

i
, mais comme on les calcule au
vol on peut les calculer tous sans surcot.
Ensuite on calcule successivement :
y
1
= (x

0
)
m
x

1
y
2
= (y
1
)
m
x

2
= x
(
0
m+
1
)m+
2
.
.
.
y
t
= (y
t1
)
m
x
t
= x
n
13
On eectue pour chaque ligne k +1 oprations (k lvations au carr pour calculer la puissance
m-me, et une multiplication), do le cot total du calcul de x
n
:
t (k + 1) + (m2).
En remplaant m par 2
k
, et t par log
m
n|, on trouve un cot total de
log
m
n|(k + 1) + 2
k
2
log
2
n
k
(k + 1) + 2
k
.
Il sut donc de prendre k tendant vers linni, pour que (k + 1)/k tende vers 1, et tel que
2
k
= o(log n), par exemple k = 1/2 log(log n)| (on aura alors 2
k

log n).
1.7 Exercices
Exercice 1.7.1. Le grand saut
Le problme est de dterminer partir de quel tage dun immeuble, sauter par une fentre
est fatal. Vous tes dans un immeuble n tages (numrots de 1 n) et vous disposez de k
tudiants. Il ny a quune opration possible pour tester si la hauteur dun tage est fatale :
faire sauter un tudiant par la fentre. Sil survit, vous pouvez le rutiliser ensuite, sinon vous
ne pouvez plus.
Vous devez proposer un algorithme pour trouver la hauteur partir de laquelle un saut est
fatal (renvoyer n + 1 si on survit encore en sautant du n-me tage) en faisant le minimum de
sauts.
1 - Si k log
2
(n)|, proposer un algorithme en O(log
2
(n)) sauts.
2 - Si k < log
2
(n)|, proposer un algorithme en O(k +
n
2
k1
) sauts.
3 - Si k = 2, proposer un algorithme en O(

n) sauts.
Correction.
1 - La complexit en O(log
2
(n)) qui est indique nous aiguille vers une dichotomie. En eet,
en supposant que lon a k log
2
(n)|, on obtient le rsultat sur les tages de i j en jetant
un tudiant depuis le n
me
tage, o n = j i/2, puis en itrant le procd sur les tages de
i n 1 si la chute t fatale, et sur les tages de n j dans le cas contraire. La mthode
dichotomique nous garantit alors que lon obtient le bon rsultat (lorsquil ne reste plus quun
seul tage, cest--dire lorsque lon calcule pour les tages de i = j), et ce avec une complexit
logarithmique dans le pire des cas.
2 - Puisquici on ne dispose que de k < log
2
(n)| tudiants, on ne peut pas appliquer directement
la mthode dichotomique propose prcdemment. Cependant, on va remdier au problme de
manire simple en appliquant une recherche dichotomique avec k 1 tudiants, de manire
dlimiter un intervalle dtages dans lequel se trouve ltage recherch. On se sert alors du dernier
tudiant restant pour parcourir lintervalle de faon linaire, donc en le jetant de chaque tage
en partant du plus bas de lintervalle, jusquau plus haut. Aprs avoir jet les k 1 premiers
tudiants, si lon na pas encore trouv le bon tage, il reste exactement n/2
k1
tages dans
lintervalle de recherche, do une complexit dans le pire des cas en O(k +n/2
k1
) sauts.
3 - Dans le cas particulier o lon a k = 2, on ne veut pas avoir tester chaque tage de faon
linaire, cest pourquoi on va reprendre notre compte les ides prcdentes, et notamment celle
qui consiste dlimiter un intervalle de recherche. Nous dcoupons donc lensemble des tages
14
en tranches de

n tages, avant de jeter le premier tudiant de chacun des tages de dbut de


tranche. Lorsque ltudiant y laisse sa peau, on se ramne au dernier tage n test qui ne soit pas
fatal, et on na plus qu parcourir de manire linaire lintervalle allant de ltage n+1 ltage
fatal trouv prcdemment. On a ainsi deux sries dessais en O(

n), et donc une complexit


nale dans le pire des cas galement en O(

n) sauts.
Exercice 1.7.2. Cherchez la star
Dans un groupe de n personnes (numrotes de 1 n pour les distinguer), une star est quelquun
qui ne connait personne mais que tous les autres connaissent. Pour dmasquer une star, sil en
existe une, vous avez juste le droit de poser des questions, nimporte quel individu i du groupe,
du type est-ce que vous connaissez j ? (not i j ?), on suppose que les individus rpondent
la vrit. On veut un algorithme qui trouve une star, sil en existe, ou sinon qui garantit quil
ny a pas de star dans le groupe, en posant le moins de questions possibles.
1 - Combien peut-il y avoir de stars dans le groupe ?
2 - Ecrire le meilleur algorithme que vous pouvez et donner sa complexit en nombre de questions
(on peut y arriver en O(n) questions).
3 - Donner une borne infrieure sur la complexit (en nombre de questions) de tout algorithme
rsolvant le problme. ((Dicile) prouver que la meilleure borne infrieure pour ce problme est
3n log
2
(n)| 3).
Correction.
1 - Il ne peut y avoir quune seule star dans le groupe, puisque sil y en a une, elle ne connait
personne, et donc tous les autres sont inconnus dau moins une personne, et ne peuvent donc
tre eux aussi des stars.
2 - Lorsquon eectue le test

i j ?

, cest--dire lorsque lon cherche savoir si la personne
i connat la personne j, on obtient le rsultat suivant :
si oui, alors i nest pas une star, mais j en est potentiellement une.
si non, alors j nest pas une star, mais i en est potentiellement une.
Lalgorithme consiste alors a parcourir le tableau des personnes une fois, en gardant en memoire
chaque instant la personne i qui est jusquici reconnue par tous, tandis quau j
me
test, toutes
les autres personnes, dont les indices sont les k < j (avec k ,= i, bien sr) ne peuvent pas des
stars. Cet algorithme scrit donc de la manire suivante :
i 1 et j 2
tant que j n faire
si

i j

alors faire j j + 1
sinon faire i j et j j + 1
i
star
vrai et k 1
tant que (k n et i
star
) faire
si

k i

alors faire k k + 1
sinon faire i
star
faux
si i
star
alors faire retourner i est la star
sinon faire retourner il ny a pas de star
3 - En observant notre algorithme, on constate que lon peut utiliser comme borne infrieure
pour le nombre de questions la valeur 3n2, puisque lon fait ici deux boucles sur n1 personnes
15
et une boucle sur lensemble des n personnes. Pour ce qui est de la borne infrieure optimale, il
sagit dune question dicile, dont on nexplicitera pas la solution ici.
Exercice 1.7.3. Bricolage
Dans une boite outils, vous disposez de n crous de diamtres tous dirents et des n
boulons correspondants. Mais tout est mlang et vous voulez appareiller chaque crou avec le
boulon qui lui correspond. Les dirences de diamtre entre les crous sont tellement minimes
quil nest pas possible de dterminer lil nu si un crou est plus grand quun autre. Il en va
de mme avec les boulons. Par consquent, le seul type dopration autoris consiste essayer un
crou avec un boulon, ce qui peut amener trois rponses possibles : soit lcrou est strictement
plus large que le boulon, soit il est strictement moins large, soit ils ont exactement le mme
diamtre.
1 - Ecrire un algorithme simple en O(n
2
) essais qui appareille chaque crou avec son boulon.
2 - Supposons quau lieu de vouloir appareiller tous les boulons et crous, vous voulez juste
trouver le plus petit crou et le boulon correspondant. Montrer que vous pouvez rsoudre ce
problme en moins de 2n 2 essais.
3 - Prouver que tout algorithme qui appareille tous les crous avec tous les boulons doit eectuer
(nlog n) essais dans le pire des cas.
Problme ouvert : proposer un algorithme en o(n
2
) essais pour rsoudre ce problme.
Correction.
1 - Algorithme
Pour appareiller les boulons et les crous, il sut de prendre un boulon arbitrairement, de
le tester avec tous les crous.On trouve alors le bon en au plus n tests et il sut alors de
recommencer avec tous les autres boulons.On obtient donc le rsultat en au plus
n(n1)
2
= O(n
2
)
tests.
2 - Le plus petit crou et son boulon
Le principe est de numroter les boulons et les crous de 1 n, de manire arbitraire, et de
faire progresser des compteurs (par exemple i et j) pour marquer le minimun courant dans lune
des catgories, et la structure en cours de test dans lautre.
dbut
while (i n) && (j n) do
si i=j=n alors sortir de la boucle ;
si ecrou.i = boulon.j alors sen souvenir et faire i := i + 1;
si ecrou.i < boulon.j alors j := j + 1 ; min = ecrou;
si ecrou.i > boulon.j alors i := i + 1 ; min = boulon;
n
A la n de cette boucle,
si min=crou, lcrou i est le plus petit.
si min=boulon, le boulon j est le plus petit. Et dans les deux cas, on sait dj quel est
llment qui correspond : en eet, le compteur de lautre catgorie vaut n+1 (ou n dans un
cas spcial),et on a donc dj rencontr le minimum. la seule raison possible pour laquelle
il na pas t conserv est donc quil ait t test avec lautre minimum. Pour le cas spcial
ou i=j=n, le dernier test est inutile : en eet, on sait que lun des deux, est minimum, et
que une fois le boulon minimum atteind, j reste xe : do le boulon n est minimum, et
son homologue a soit dj t trouv, soit est lcrou restant.
16
Cette boucle eectue donc au plus 2 n 2 tests.
3 - Algorithme dappareillage des crous et de leur boulon
On note f(T) le nombre de feuilles de larbre et h(T) sa hauteur. Si T est un arbre ternaire
h(T) log
3
f(T)|. Par induction sur la hauteur de T :
Pour h(T) = 0 larbre une feuille donc on a bien h(T) log
3
f(T).
Pour h(T) > 0 un arbre ternaire a trois ls, le ls gauche fg, le ls central fc, et le
ls droit fd de hauteur infrieur h(T) 1.On suppose que h(T) log
3
f(T)| est vrai
pour h(T) k k tant x on veut dmontrer que cette proprit est vrai aussi pour
h(T) = k + 1. Les feuilles dun arbre sont aussi celles de ses ls. Donc
h(T)
f(fc) f(fg)
fg fc
f(fd)
fd
f(T)
T
h(T)-1
f(T) = f(fd) +f(fg) +f(fd)
de plus :
h(T) h(fd) + 1
h(T) h(fg) + 1
h(T) h(fc) + 1
or par induction comme h(T) = k + 1, h(fg) k, h(fg) k,et h(fg) k on a :
k = h(fc) log
3
f(fc)|
h(fd) log
3
f(fd)|
h(fg) log
3
f(fg)|
Donc f(fc), f(fg), f(fd) 3
k
or :
f(T) = f(fc) +f(fg) +f(fd)
donc :
f(T) 3 3
k
= 3
k+1
D o on en dduit que :
h(T) log
3
f(T)
Il y a !n agencements boulons-crous possibles donc larbre de dcision, qui est ternaire a pour
hauteur : log
3
!n nlog
3
n, donc la complexit dans le pire cas de lalgo est de : (n logn).
1.8 Rfrences bibliographiques
La prsentation du cours sinspire de Knuth [6]. Les exercices Le grand saut et Bricolage
sont tirs de Rawlins [8].
17
18
Chapitre 2
Diviser pour rgner
2.1 Algorithme de Strassen
Calculons un produit de matrices :
_
r s
t u
_
=
_
a b
c d
_

_
e f
g h
_
Lalgorithme classique calcule en Add(n) = n
2
(n 1) additions et Mult(n) = n
3
multipli-
cations. En eet, il y a n
2
coecients calculer, chacun correspondant un produit scalaire de
taille n, donc avec n multiplications, n 1 additions, et une aectation. Peut-on faire mieux ?
1
V. Strassen rpond que oui : soient
p
1
= a(g h)
p
2
= (a +b)h
p
3
= (c +d)e
p
4
= d(f e)
p
5
= (a +d)(e +h)
p
6
= (b d)(f +h)
p
7
= (a c)(e +g)
alors on peut crire
r = p
5
+p
4
p
2
+p
6
s = p
1
+p
2
t = p
3
+p
4
u = p
5
+p
1
p
3
p
7
Comptons maintenant les oprations :
Classique Strassen
Mult(2) = 8 Mult(2) = 7
Add(2) = 4 Add(2) = 18
On a gagn une multiplication, mais en perdant 14 additions ; donc, pour des matrices 2x2,
cest un bilan ngatif. Par contre, il est remarquable que lopration ne ncessite pas la commu-
tativit de la multiplication. On peut donc lutiliser avec des matrices de taille n paire.
1
Dans les temps anciens de linformatique, il tait surtout intressant de diminuer le nombre de multiplications,
quitte augmenter le nombre dadditions. Larchitecture pipeline des processeurs actuels permet de raliser, en
moyenne, une addition ou une multiplication par temps de cycle.
19
Supposons donc n = 2m pair, et utilisons la mthode prcdente une seule fois, en par-
titionnant chaque matrice de dpart en quatre sous-blocs de taille m m. On eectuera m
3
multiplications pour chaque p
i
, do un total de Mult(n) = 7m
3
= 7n
3
/8 multiplications. Pour
les additions, il y a deux sources : les additions eectues dans chaque produit p
i
, donc au
nombre de 7m
2
(m 1), et les additions pour former les 18 matrices auxiliaires, au nombre de
18m
2
. Do Add(n) = 7m
3
+ 18m
2
= 7n
3
/8 + 18n
2
/4. Asymptotiquement, le terme dominant
est en n
3
/7 pour Mult(n) comme pour Add(n), et la nouvelle mthode est gagnante pour n
assez grand. La raison profonde est la suivante : une multiplication de deux matrices de taille n
requiert O(n
3
) oprations, alors que leur addition nen demande que O(n
2
). Pour n grand, les
additions sont gratuites en face des multiplications. Ce qui ntait pas le cas pour les nombres
rels.
Lalgorithme de Strassen est lapplication rcursive de la dcomposition prcdente. On consi-
dre le cas o n est une puissance de 2, i.e. n = 2
s
. Si n nest pas une puissance de 2, on tend
les matrices avec des 0 la puissance de 2 suprieure :
_
X 0
0 0
_
et on remplacera dans les formules qui suivent log n par log n|.
Prenons donc n = 2
s
. On fonctionne de manire rcursive : on refait le mme dcoupage pour
chacun des produits de matrice p
i
. On sarrtera quand on arrive des matrices de taille 1, ou
mieux, la taille pour laquelle la mthode est plus coteuse que la mthode classique (n 32).
Soient :
M(n) = nombre de multiplications ralises par lalgorithme de Strassen pour multiplier
2 matrices de taille n
A(n) = nombre dadditions ralises par lalgorithme de Strassen pour multiplier 2 ma-
trices de taille n
On a :
_
M(1) = 1
M(n) = 7 M(n/2)
=M(n) = 7
s
= 7
log
2
(n)
= n
log
2
(7)
Comme prcdemment, les additions viennent de 2 sources : les additions lies aux additions
de matrices pour la construction des termes p
i
et les additions eectues pour les multiplications
de matrices (appels rcursifs). On a donc :
_
A(1) = 0
A(n) = 7 A(n/2) + 18 (n/2)
2
=A(n) = 6 (n
log
2
(7)
n
2
)
(on verra Section 2.4 comment rsoudre cette rcurrence). On voit que lordre de grandeur du
cot des calculs nest plus en n
3
, mais seulement en n
log
2
7
.
Lalgorithme de Strassen nest pas souvent utilis car il introduit des problmes dinstabi-
lit numrique. Notons enn quil existe des algorithmes de complexit meilleure que celle de
Strassen, et que le problme de dterminer la complexit du produit de deux matrices est encore
ouvert. La seule borne infrieure connue est en O(n
2
) : il faut bien toucher chaque coecient au
moins une fois.
2.2 Produit de deux polynmes
Le but est de multiplier deux polynmes. On notera n-polynmes les polynmes de degr
strictement infrieur n, donc avec n coecients. Soient :
P : n-polynme :

n1
i=0
a
i
X
i
20
Q : n-polynme :

n1
i=0
b
i
X
i
R = P Q =? : (2n 1)-polynme
Soient :
M(n) = nombre de multiplications ralises par lalgorithme pour multiplier deux n-
polynmes
A(n) = nombre dadditions ralises par lalgorithme pour multiplier deux n-polynmes
Avec lalgorithme usuel de multiplication de n-polynmes :
M(n) = n
2
et A(n) = n
2
(2n 1)
. .
affectations
= (n 1)
2
On suppose n pair, n = 2m
P = P
1
+X
m
P
2
Q = Q
1
+X
m
Q
2
_
avec P
1
, P
2
, Q
1
, Q
2
m-polynmes
Soient :
R
1
= P
1
Q
1
R
2
= P
2
Q
2
R
3
= (P
1
+P
2
) (Q
1
+Q
2
)
On a alors : R = R
1
+ (R
3
R
2
R
1
) X
m
+R
2
X
2m
Quel est lintrt ? On ne ralise que 3 multiplications de polynmes de taille moiti. Les ad-
ditions sont de deux types : les additions de polynmes, et les additions lies aux multiplications
de m-polynmes.
On suppose maintenant que n = 2
s
et on applique lalgorithme de manire rcursive.
_
M(1) = 1
M(n) = 3 M(n/2)
=M(n) = 3
s
= n
log
2
(3)
_
_
_
A(1) = 0
A(n) = 3 A(n/2)
. .
appels recursifs
+ 2 n/2
. .
pour avoir R
3
+ 2 (n 1)
. .
pour avoir R
3
R
2
R
1
+ (n 2)
. .
construction de R
En eet, pour la construction de R :
R = R
1
+ (R
3
R
1
R
2
) X
m
+R
2
X
2m
=
n2

i=0
r
1
i
X
i
. .
X
0
X
n2
+
n2

i=0
z
i
X
i+n/2
+
n2

i=0
r
2
i
X
i+n
. .
X
n
X
2n2
Tous les termes du terme du milieu sadditionnent aux termes de gauche et de droite, il faut
donc faire n 2 additions. Do :
_
A(1) = 0
A(n) = 3 A(n/2) + 4 n 4
=A(n) = 6n
log
2
(3)
8n + 2
(on verra Section 2.4 comment rsoudre cette rcurrence)
Remarque Le meilleur algorithme de multiplication de polynmes est en O(nlog(n)), il est
obtenu par transforme de Fourrier rapide (FFT).
_

_P, Q
..
evaluation
P(x
i
), Q(x
i
)
. .
en 2n points
P(x
i
) Q(x
i
)
..
interpolation
P Q
_

_
Lvaluation et linterpolation sont ralises en n
2
par la mthode classique, en utilisant Newton
et Lagrange. Pour la FFT, on value les polynmes en les racines complexes de lunit.
21
2.3 Master theorem
Diviser pour rgner :
On considre un problme de taille n, quon dcoupe en a sous-problmes de taille n/b permettant
de rsoudre le problme. Le cot de lalgorithme est alors :
_
_
_
S(1) = 1
S(n) = a S(n/b) +Reconstruction(n)
. .
cn

en general
_
_
a b c
Strassen 7 2 2 18
Polynomes 3 2 1 4
_
_
S(n) = a S(n/b) +R(n) = a
2
S(n/b
2
) +a R(n/b) +R(n) = . . .
On pose n = b
k
, on a alors :
S(n) = a
k
..
n
log
b
(a)
S(1) +
k1

i=0
a
i
R(n/b
i
)
. .
avec R(n) = c n

et :

= c n

k1

i=0
(a/b

)
i
On distingue alors plusieurs cas :
1. (a > b

) :

n

(
a
b

)
k
a
k
=S(n) = O(n
log
b
(a)
)
2. (a = b

) :

k n

=S(n) = O(n

log(n))
3. (a < b

) :

c n

1
1
a
b

=S(n) = O(n

)
Retour sur Strassen :
A la lumire de ce qui prcde, et si on dcoupait les matrices en 9 blocs de taille n/3 au lieu
de 4 blocs de taille n/2 ?
_
_
_
_

_
_
_
_
On a :
a b c
a 3 2
Pour que lalgorithme soit plus intressant que Strassen, il faut que :
log
3
(a) < log
2
(7)
a < e
log
2
(7)log
2
(3)
a < 7
log
2
(3)
21, 8
Cest un problme ouvert : on connat une mthode avec a = 23 mais pas avec a = 21 !
22
2.4 Rsolution des rcurrences
2.4.1 Rsolution des rcurrences homognes
_
p
0
s
n
+p
1
s
n1
+ +p
k
s
nk
= 0
p
i
constantes
Soit P =

k
i=0
p
i
X
ki
. On cherche les racines de P. Si les racines de P sont distinctes :
s
n
=
k

i=0
c
i
r
i
n
Sinon, si q
i
est lordre de multiplicit de r
i
s
n
=
l

i=0
P
i
(n)
. .
polynome de degre q
i
1
r
i
n
2.4.2 Rsolution des rcurrences avec second membre
On note E loprateur de dcalage : E{s
n
} = {s
n+1
} On dnit les oprations suivantes sur
les suites :
c.{s
n
} = {c.s
n
} (2.1)
(E
1
+E
2
){s
n
} = E
1
{s
n
} +E
2
{s
n
} (2.2)
(E
1
E
2
){s
n
} = E
1
(E
2
{s
n
}) (2.3)
_
ex :
(E 3){s
n
} = {s
n+1
3s
n
}
(2 +E
2
){s
n
} = {2s
n
+s
n+2
}
_
P(E) annule {s
n
} si P(E){s
n
} = 0 ex :
suite annulateur
{c} E 1
{Q
k
(n)} (E 1)
k+1
{c
n
} E c
{c
n
Q
k
(n)} (E c)
k+1
o Q
k
(n) est un polynme de degr k. En eet, il sut de montrer la dernire relation, par
rcurrence sur k :
(E c)
k+1
{c
n
Q
k
(n)}
. .
{c
n
(a
0
n
k
+Q
k1
(n))}
= (E c)
k
[(E c){c
n
(a
0
n
k
+Q
k1
(n))}]
. .
{c
n+1
(a
0
(n+1)
k
+Q
k1
(n+1))c
n+1
(a
0
n
k
+Q
k1
(n))}
= (E c)
k
[c
n+1
R
k1
(n)]
= 0
(par hypothse de rcurrence)
Rsolution pour les additions dans lalgorithme de Strassen :
A(n) = 7 A(n/2) + 18
n
2
4
23
On a n = 2
s
, on pose A
s
= A(2
s
)
A
s+1
= 7 A
s
+ 18
(2
s+1
)
2
4
= 7 A
s
+ 18 4
s
(E 4) (E 7){A
s
}
. .
A
s+1
7As=184
s
= 0
A
s
= k
1
7
s
+k
2
4
s
avec :
A
0
= 0
A
1
= 18
On en dduit les valeurs de k
1
et k
2
donnes plus haut.
Rsolution pour les additions dans lalgorithme de multiplication de polynmes :
A(n) = 3 A(n/2) + 4n 4
A
s
= 3 A
s1
+ 4 2
s
4
Do : (E 1)(E 2)(E 3){A
s
} = 0
A
s
= k
1
3
s
+k
2
2
s
+k
3
avec :
A
0
= 0
A
1
= 4
A
2
= 24
On en dduit les valeurs de k
1
= 6, k
2
= 8 et k
3
= 2 donnes plus haut.
2.5 Multiplication et inversion de matrices
Soient :
M(n) = cot de la multiplication de 2 matrices dordre n
I(n) = cot de linversion dune matrice dordre n
Hypothses :
O(n
2
)
M(n)
I(n)
O(n
3
)
M(n) et I(n) croissants
Thorme 3. M(n) et I(n) ont le mme ordre de grandeur.
Preuve. On montre que chaque opration est au moins aussi dicile que lautre :
La multiplication est au moins aussi complexe que linversion
On veut multiplier les matrices A et B de taille n. Soit Z de taille 3n suivante :
Z =
_
_
I A 0
0 I B
0 0 I
_
_
Z
1
=
_
_
I A A.B
0 I B
0 0 I
_
_
Do : M(n) I(3n)
24
Linversion est au moins aussi complexe que la multiplication
On procde en deux tapes :
Si A est symtrique dnie positive
A =
_
B
t
C
C D
_
Soit S = D C.B
1
.
t
C (Shur complement).
A
1
=
_
B
1
+B
1
.
t
C.S
1
.C.B
1
B
1
.
t
C.S
1
S
1
.C.B
1
S
1
_
Il sut de construire :
B
1
, C.B
1
, (C.B
1
).
t
C, S
1
, S
1
.(C.B
1
),
t
(C.B
1
).(S
1
.C.B
1
)
do : I(n) = 2 I(n/2) + 4 M(n) +O(n
2
) = O(M(n))
Cas gnral On pose B =
t
A A. On veut calculer A
1
, et on sait calculer B
1
car B est
symtrique dnie positive.
I = B
1
.B = B
1
.(
t
A.A) = (B
1
.
t
A).A A
1
= B
1
.
t
A
Do : I(n) = 2 M(n) +O(M(n)) = O(M(n))
2.6 Exercices
Exercice 2.6.1. Matrices de Tplitz
Une matrice de Tplitz est une matrice n n (a
i,j
) telle que a
i,j
= a
i1,j1
pour 2 i, j n.
1 - La somme de deux matrices de Tplitz est-elle une matrice de Tplitz ? Et le produit ?
2 - Trouver un moyen dadditionner deux matrices de Tplitz en O(n).
3 - Comment calculer le produit dune matrice de Tplitz n n par un vecteur de longueur n?
Quelle est la complexit de lalgorithme ?
Correction.
1 Par linarit, la somme de deux Tplitz reste une Tplitz. Ce nest pas vrai pour le produit.
Par exemple,
_
1 0
1 1
_

_
1 1
0 1
_
=
_
1 1
1 2
_
2 On nadditionne que les premires lignes et les premires colonnes, ce qui fait 2n 1 opra-
tions.
3 On ne considre que les matrices de taille 2
k
2
k
.
On dcompose la matrice en blocs de taille n = 2
k1
MT =
_
A B
C A
_

_
X
Y
_
25
On pose :
U = (C +A)X
V = A(Y X)
W = (B +A)Y
et on calcule :
MT =
_
W V
U +V
_
Calcul de la complexit : On note respectivement M(n) et A(n) le nombre de multiplications et
dadditions pour un produit de matrices n n.
M(2
k
) = 3M(2
k1
)
M(1) = 1
A(2
k
) = 3A(2
k1
) + 2(2
k
1) + 3.2
k1
A(1) = 0
On rsoud les rcurrences :
on pose M
s
= M(2
s
), et on pose A
s
= A(2
s
).
le calcul pour les multiplications :
_
M
s
= 3M
s1
M
0
= 1
(E 3)M
s
=

0; M
s
= 3
log n
= n
log 3
puis le calcul pour les additions :
_
A
s
= 3A
s1
+ 7.2
s1
2
A
0
= 0
(E 3)(E 2)(E 1){A
s
} =

0
A
s
= i3
s
+j2
s
+l
A
0
= A(1) = 0 i +j +l = 0
A
1
= A(2) = 5 3i + 2j +l = 5
A
2
= A(4) = 27 9i + 4j +l = 27
Do i = 6, j = 7, l = 1
26
Exercice 2.6.2. Recherche dun lment majoritaire
Soit E une liste de n lments rangs dans un tableau numrot de 1 n. On suppose que la
seule opration quon sait eectuer sur les lments est de vrier si deux lments sont gaux
ou non. On dit quun lment x E est majoritaire si lensemble E
x
= {y E|y = x} a
strictement plus de n/2 lments. Sauf avis contraire, on supposera que n est une puissance de
2. On sintressera la complexit dans le pire des cas.
1 - Algorithme naf
crire un algorithme calculant le cardinal de c
x
de E
x
pour un x donn. En dduire un
algorithme pour vrier si E possde un lment majoritaire. Quelle est la complexit de cet
algorithme ?
2 - Diviser pour rgner
2.1- Donner un autre algorithme rcursif bas sur un dcoupage de E en deux listes de mme
taille. Quelle est sa complexit ?
2.2 - Donner un algorithme similaire (en prcisant sa complexit) dans le cas gnral o n nest
pas une puissance de 2.
3 - Encore mieux
Pour amliorer lalgorithme prcdent, on va se contenter dans un premier temps de mettre
au point un algorithme possdant la proprit suivante :
soit lalgorithme garantit que E ne possde pas dlment majoritaire,
soit lalgorithme fournit un entier p > n/2 et un lment x tels que x apparaisse au plus
p fois dans E et tout lment autre que x apparat au plus n p fois dans E.
3.1 - Donner un algorithme rcursif possdant cette proprit. Quelle est sa complexit ?
3.2 - Mme question quand n nest pas une puissance de 2.
3.3 - En dduire un algorithme ecace vriant si E possde un lment majoritaire.
4 - Encore encore mieux
On change la manire de voir les choses. On a un ensemble de n balles et on cherche le cas
chant sil y a une couleur majoritaire parmi les balles.
4.1 - Supposons que les balles soient ranges en le sur une tagre, de manire navoir jamais
deux balles de la mme couleur ct. Que peut-on en dduire sur le nombre maximal de balles
de la mme couleur ?
On a un ensemble de n balles, une tagre vide o on peut les ranger en le et une corbeille
vide. Considrons lalgorithme suivant :
- Phase 1 - Prendre les balles une par une pour les ranger sur ltagre ou dans la corbeille.
SI la balle nest pas de la mme couleur que la dernire balle sur ltagre, la ranger ct,
et si de plus la corbeille nest pas vide, prendre une balle dans la corbeille et la ranger ct
sur ltagre. SINON, cest dire si la balle est de la mme couleur que la dernire balle sur
ltagre, la mettre dans la corbeille.
- Phase 2 - Soit C la couleur de la dernire balle sur ltagre la n de la phase 1. On
compare successivement la couleur de la dernire balle sur ltagre avec C. SI la couleur est la
mme on jette les deux dernires balles sur ltagre, sauf sil nen reste quune, auquel cas on
la met dans la corbeille. SINON on la jette et on jette une des balles de la corbeille, sauf si la
27
corbeille est dj vide auquel cas on sarrte en dcrtant quil ny a pas de couleur majoritaire.
Quand on a puis toutes les balles sur ltagre, on regarde le contenu de la corbeille. Si elle
est vide alors il ny a pas de couleur majoritaire, et si elle contient au moins une balle alors C
est la couleur majoritaire.
4.2 - (Correction de lalgorithme) Montrer qu tout moment de la phase 1, toutes les balles
ventuellement prsentes dans la corbeille ont la couleur de la dernire balle de ltagre. En
dduire que sil y a une couleur dominante alors cest C.
Prouver la correction de lalgorithme.
4.3 - (Complexit) Donner la complexit dans le pire des cas en nombre de comparaisons de
couleurs des balles.
5 - Optimalit
On considre un algorithme de majorit pour les couleurs de n balles. Le but est de regarder
faire lalgorithme, en choisissant au fur et mesure les couleurs des balles pour que lalgorithme
ait le maximum de travail (tout en restant cohrent dans le choix des couleurs). On obtiendra
ainsi une borne infrieure de complexit pour un algorithme de majorit. Cest la technique de
ladversaire.
tout moment de lalgorithme, on aura une partition des balles en deux ensembles : larne
et les gradins. Larne contient un certain nombre de composantes connexes de deux sortes : les
binmes et les troupeaux. Un binme est un ensemble de deux balles pour lesquelles lalgorithme a
dj test si elles taient de la mme couleur et a rpondu non. Un troupeau est un ensemble non
vide de balles de la mme couleur, connectes par des tests de lalgorithme. Ainsi, un troupeau
avec k lments a subi au moins k 1 comparaisons de couleurs entre ses membres. Soient B le
nombre de binmes et T le nombre de troupeaux. Soient g le nombre dlments dans les gradins
et t le nombre total dlments dans tous les troupeaux. Enn, soit m = n/2| + 1 le seuil de
majorit.
Au dbut de lalgorithme toutes les balles sont des troupeaux un lment. La stratgie de
ladversaire est la suivante. Lalgorithme eectue un test couleur(x) = couleur(y)?
1. Si x ou y sont dans les gradins, la rponse est non.
2. Si x (resp. y) est dans un binme, la rponse est non et x (resp. y) est envoy dans les
gradins alors que llment restant devient un troupeau singleton.
3. Si x et y sont dans le mme troupeau la rponse est oui.
4. Si x et y sont dans des troupeaux dirents alors cela dpend de d = B +t.
(a) d > m : cela signie que les balles sont dans des troupeaux singletons. La rponse est
non et les balles deviennent un nouveau binme.
(b) d = m : la rponse est oui et les troupeaux de x et y fusionnent.
5.1 - Vrier que les quatre cas prcdents traitent tous les cas possibles.
Montrer qu tout moment d m et que si d > m alors tous les troupeaux sont des singletons.
5.2 - Montrer qu tout moment les deux coloriages suivants sont consistants avec les rponses
de ladversaire :
(i) Toutes les balles sont de couleurs direntes sauf celles qui sont dans un mme troupeau.
(ii) Une mme couleur est attribue toutes les balles de tous les troupeaux et une balle
de chaque binme. Les balles restantes ont chacune une couleur distincte.
5.3 - Montrer que si un algorithme correct sarrte alors larne ne contient quune seule compo-
sante connexe qui est un troupeau de taille m.
28
5.4 - tout moment le nombre de comparaisons ingales eectues par lalgorithme est au moins
2g +B et le nombre de comparaisons gales est au moins t T.
5.5 - Considrons un algorithme qui rsout la majorit. Montrer quil existe une donne pour
laquelle lalgorithme eectue au moins 2(n m) = 2n/2| 1 comparaisons dingalit et au
moins n/2| comparaisons dgalit, et donc au moins au total 3n/2| 2 comparaisons.
Correction.
On se restreint ici aux algorithmes o la seule opration quon sait eectuer sur les lments est
de tester si deux lments sont gaux. Si la rponse est OUI, on dira quil sagit dune comparaison
gale, et si la rponse est NON dune comparaison ingale.
Remarque : sil existe un lment majoritaire, il est ncessairement unique.
1 - Algorithme naf
dbut
pour i de 1 n faire
c 0 ;
pour j de 1 n faire
si E[j] = E[i] alors c c + 1 ;
si c > n/2 alors retourner E[i] est majoritaire
Retourner Pas dlment majoritaire.
n
Complexit : nombre total de comparaisons = n
2
.
2 - Diviser pour rgner
E E E
1 2
n/2 n/2
2.1 - Principe :
Couper E en deux tableaux E
1
et E
2
de tailles n/2 (on suppose n pair).
Sil existe un lment majoritaire x dans E, alors x est majoritaire dans au moins une
des deux listes E
1
et E
2
(en eet si x non majoritaire dans E
1
, ni dans E
2
, alors dans E,
c
x
n/4 +n/4 = n/2).
Algorithme rcursif : calculer les lments majoritaires de E
1
et de E
2
(sils existent) avec
le nombre total doccurences de chacun et en dduire si lun des deux est majoritaire dans
E.
Lalgorithme suivant Majoritaire(i, j) renvoie un couple qui vaut (x, c
x
) si x est majoritaire
dans le sous-tableau E[i..j] avec c
x
occurences et qui vaut (, 0) sil ny a pas de majoritaire dans
E[i..j], lappel initial tant Majoritaire(1, n). La fonction Occurence(x, i, j) calcule le nombre
doccurences de x dans le sous-tableau E[i..j].
29
Algorithm:Majoritaire(i, j)
dbut
si i = j alors retourner (E[i], 1) ;
sinon
(x, c
x
) = Majoritaire(i, (i +j)/2|) ;
(y, c
y
) = Majoritaire((i +j)/2| + 1, j) ;
si c
x
,= 0 alors c
x
c
x
+Occurence(x, (i +j)/2| + 1, j) ;
si c
y
,= 0 alors c
y
c
y
+Occurence(x, i, (i +j)/2|) ;
si c
x
> (j i + 1)/2| alors retourner (x, c
x
) ;
sinon si c
y
> (j i + 1)/2| alors retourner (y, c
y
) ;
sinon retourner (, 0).
n
Complexit : le nombre total de comparaisons dans le pire des cas C(n) vrie la relation (on
suppose que n est une puissance de 2) :
C(n) = 2(C(
n
2
) +
n
2
) avec C(1) = 0
On en dduit C(n) = nlog
2
(n).
2.2 - Si n nest pas une puissance de 2, les trois points du principe prcdent restent vrais en
coupant E en un tableau de taille n/2| et lautre de taille n/2|, et lalgorithme dcrit ci-
dessus fonctionne sans aucune modication. La rcurrence pour la complexit est alors C(n) =
C(
n
2
|) +C(
n
2
|) +n avec C(1) = 0, dont la rsolution donne C(n) nlog
2
(n).
3 - Encore mieux
Remarque 1 : soit x vriant la proprit, alors aucun autre lment z ,= x ne peut tre
majoritaire (car c
z
np < n/2), donc, dans ce cas, x est un candidat-majoritaire. Autrement
dit un algorithme vriant les proprits de lexercice nous fournit :
soit la garantie quil nexiste aucun lment majoritaire,
soit un candidat-majoritaire x, dont on peut vrier ensuite sil est vraiment majoritaire
en reparcourant une fois le tableau (soit n 1 comparaisons).
Remarque 2 : un lment majoritaire x est bien un candidat-majoritaire avec p = c
x
(donc sil
existe un majoritaire, il sera bien propos comme candidat-majoritaire par lalgorithme).
3.1 - Algorithme rcursif Candidat majoritaire(E) renvoyant AUCUN sil ny a pas dlment
majoritaire dans E et sinon renvoyant (x, p) avec les bonnes proprits.
30
Algorithm:Candidat majoritaire(E)
dbut
si E na quun lment x alors retourner (x, 1) ;
sinon
couper E en deux tableaux E
1
et E
2
de taille n/2 ;
appeler Candidat majoritaire(E
1
) qui renvoie AUCUN ou (x, p) ;
appeler Candidat majoritaire(E
2
) qui renvoie AUCUN ou (y, q) ;
suivant la rsponse pour E
1
et E
2
, faire
si AUCUN et AUCUN alors retourner AUCUN ;
si AUCUN et (y, q) alors retourner (y, q +
n
4
) ;
si (x, p) et AUCUN alors retourner (x, p +
n
4
) ;
si (x, p) et (y, q) alors
si x ,= y et p > q alors retourner (x, p +
n
2
q) ;
si x ,= y et p < q alors retourner (y, q +
n
2
p) ;
si x ,= y et p = q alors retourner AUCUN
(sinon ce serait x ou y mais c
x

n
2
et c
y

n
2
) ;
si x = y alors retourner (x, p +q)
n
Complexit : on a suppos n un puissance de 2, le nombre de comparaisons C(n) pour un
tableau n lments vrie : C(n) = 2C(
n
2
) + 1 avec C(1) = 0, ce qui donne C(n) = n 1.
3.2 - Si on ne suppose pas que n est une puissance de 2, couper E en deux tableaux de tailles

n
2
| et
n
2
|, et aner lanalyse.
Si n est pair, faire comme la question prcdente en remplaant juste
n
4
par
n
4
|. La complexit
vrie alors C(n) = C(
n
2
|) +C(
n
2
|) + 1.
Si n est impair, n = 2m+ 1, adapter la procdure prcdente de la manire suivante :
dbut
si m = 0, E na quun lment x alors retourner (x, 1) ;
sinon
couper E en un tableau E
1
de taille m et un tableau E
2
de taille m+ 1 ;
appeler Candidat majoritaire(E
1
) qui renvoie AUCUN ou (x, p) ;
appeler Candidat majoritaire(E
2
) qui renvoie AUCUN ou (y, q) ;
suivant la rsponse pour E
1
et E
2
, faire
si AUCUN et AUCUN alors retourner AUCUN ;
si AUCUN et (y, q) alors retourner (y, q +
m
2
|) ;
si (x, p) et AUCUN alors retourner (x, p +
m+1
2
|) ;
si (x, p) et (y, q) alors
si x ,= y et p q alors retourner (x, p +m+ 1 q) ;
si x ,= y et q p + 1 alors retourner (y, q +mp) ;
si x = y alors retourner (x, p +q)
n
La complexit vrie toujours C(n) = C(
n
2
|) + C(
n
2
|) + 1 avec C(1) = 0. La rsolution de
cette formule de rcurrence donne C(n) = n 1.
3.3 - Algorithme complet pour rechercher un majoritaire :
Recherche dun candidat-majoritaire avec lalgorithme prcdent, soit n1 comparaisons.
Si lalgorithme renvoie un candidat, vrication que le candidat est bien majoritaire en
reparcourant le tableau, soit n 1 comparaisons.
31
Complexit au total = 2n 2 comparaisons.
4 - Encore encore mieux
4.1 - Soit k le nombre de balles ranges en le sur ltagre telles que deux balles conscutives
naient jamais la mme couleur, alors le nombre de balles dun mme couleur est toujours
k
2
|.
Preuve prcise : utiliser le lemme des tiroirs, cest dire si M chaussettes sont ranges parmi
m tiroirs avec M > m, alors il existe un tiroir avec au moins deux chaussettes. Ici dcouper
ltagre en
k
2
| tiroirs disjoints qui sont des paires demplacements conscutifs sur ltagre. Sil
y a plus de
k
2
| balles dune mme couleur, il en existe deux dans un mme tiroir, cest dire
ici adjacentes sur ltagre.
4.2 - Correction de lalgorithme : on montre des invariants (proprits restants vraies pendant
une phase de lalgorithme).
- Phase 1 -
Invariant 1 : si la corbeille nest pas vide, toutes les balles dans la corbeille ont la mme couleur
que la dernire ballle sur ltagre.
Preuve : montrer que si la prop. est vraie un instant donn, elle reste vraie ltape suivante.
Plusieurs cas peuvent se produire ici, vrier la conservation de la proprit dans chaque cas (
faire) :
ajout dune balle dirente de la dernire et corbeille pleine ...
ajout dune balle dirente de la dernire et corbeille vide ...
ajout dune balle identique la dernire ...
Invariant 2 : sur ltagre, il ny a jamais deux balles de mme couleur cte cte.
Preuve : idem au cas par cas.
Fin de Phase 1 : soit C la couleur de la dernire balle sur ltagre. Les balles dautres couleurs
sont dans les k 1 premires balles de ltagre, o k est le nombre de balles sur ltagre et
k n. Comme il ny a pas deux balles adjacentes de mme couleur, daprs la question 1,
le nombre de balles dune couleur dirente de C est
n1
2
| =
n
2
|. Donc la seule couleur
candidate pour tre majoritaire est C.
- Phase 2 - vrie si C est bien majoritaire :
Quand on retire une paire de balles, on en a toujours une de couleur C et lautre dirente,
donc C est majoritaire si et seulement si une majorit de balles la n (tagre + corbeille)
est de couleur C.
Deux cas de n se prsentent :
La phase 2 sarrte car on a besoin dune balle de la corbeille mais la corbeille est
vide. Dans ce cas, la dernire balle sur ltagre nest pas de couleur C et daprs la
question 1, au plus la moiti des balles restant sur ltagre sont de couleur C, il ny a
pas de majoritaire. Ok, cest bien ce que rpond lalgorithme.
Lalgorithme va jusquau bout de ltagre, les balles restantes (sil en reste) sont dans
la corbeille, elles sont toutes de couleur C. Donc C est majoritaire si et seulement si la
corbeille est non vide, cest bien le test eectu par lalgorithme.
4.3 - Complexit :
Phase 1 : (n 1) comparaisons (1 car la premire balle est directement pose sur ltagre).
Phase 2 : une comparaison par paire de balles limines, plus ventuellement une comparaison
avec C pour la dernire balle de ltagre sil en reste une unique, soit
n
2
| comparaisons (1
car au dbut de la phase 2, on sait que la dernire balle sur ltagre est de couleur C).
Complexit totale
3n
2
| comparaisons.
32
5 - Optimalit
5.1 - Tous les cas possibles sont bien reprsents. Au dpart d = n et tous les troupeaux sont
des singletons. Quels cas modient d ?
Cas 1 : non.
Cas 2 : non (car -1 binme, +1 dans les troupeaux).
Cas 3 : non.
Cas 4(a) : oui, d diminue de 1 (mais les troupeaux restent des singletons).
Cas 4(b) : non.
Conclusion :
Invariant d m (si d change, cest que d > m avec le cas 4(a) et alors d 1 m).
d > m implique que tous les troupeaux sont des singletons.
5.2 - Consistence des rponses de ladversaire tout moment.
Coloration (i) : correspond bien aux rponses donnes, car respecte les binmes (comparaisons
ingales) et les troupeaux (comparaisons gales). De plus les balles envoyes dans les gradins ont
toujours engendr la rponse NON aux comparaisons, ce qui fonctionne si leurs couleurs sont
toutes direntes et direntes des couleurs des balles dans larne.
Coloration (ii) : idem avec de plus le fait quune balle dans un binme na jamais t compare
quelquun dautre que son binme (donc pas de risque de contradiction avec les choix des
couleurs ailleurs).
5.3 - Un algorithme correct ne peut sarrter que si larne ne contient quune composante
connexe qui sera un troupeau de taille m.
Preuve par labsurde : supposons que larne contienne au moins deux composantes (ce qui
implique n 2 et m 2). Par dnition de d, chaque troupeau contient < d balles. Chaque
troupeau contient donc < m balles, car soit d = m, soit d > m et daprs la question 1 chaque
troupeau est un singleton. La coloration (i) na pas dlment majoritaire, mais la coloration (ii)
a un lment majoritaire (car d m). Donc aucun algorithme correct ne peut sarrter cet
instant.
Conclusion : la n, il y a ncessairement une unique composante, ncessairement de taille
d = m (par dnition de d et daprs la question 1 qui implique que d ,> m).
5.4 - A tout moment, on a eu jusqu prsent :
Nombre de comparaisons ingales 2g + B, car il faut 2 comparaisons ingales pour
mettre une balle dans les gradins (entre dans un binme puis sortie du binme) et il y a
B comparaisons ingales qui ont construit les binmes en place.
Nombre de comparaisons gales t T, car un troupeau i avec t
i
balles est connexe donc
il a t
i
1 artes, soit ici t
i
1 comparaisons gales.
5.5 - En n dalgorithme, daprs la question 3, g = n m, B = 0, t = m et T = 1. Donc,
avec la question 4, il y a eu 2(n m) = 2
n
2
| 2 comparaisons ingales et m 1 =
n
2
|
comparaisons gales, soit au total
3n
2
| comparaisons.
2.7 Rfrences bibliographiques
La prsentation du cours, et lexercice Matrices de Toeplitz, sinspirent du Cormen [2]. Lexer-
cice Recherche dun lment majoritaire est tir de Darte et Vaudenay [4].
33
Gradins
Gradins
Gradins
Arene
Arene
Arene
Dpart
Pendant
Fin
troupeau
binome
34
Chapitre 3
Programmation dynamique
3.1 Pices de Monnaies
On dispose de pices en nombre illimit, de valeurs 10, 5, 2 et 1. On veut arriver a une somme
S avec le minimum de pices.
Algorithme Glouton : Trier les types de pices par valeurs dcroissantes. Pour chaque valeur
de pice, maximiser le nombre de pices choisies. Plus formellement, soit R la somme restante,
initialise S. Pour chaque valeur v
i
, prendre c
i
=
R
v
i
| pices, et poser R R c
i
v
i
.
Pour prouver loptimalit de lalgorithme glouton avec les valeurs 10, 5, 2 et 1 :
Au plus une pice de 5 (sinon une de 10)
Au plus une pice de 1 (sinon une de 2)
Au plus deux pices de 2 (sinon une de 5 et une de 1)
Au plus quatre pices qui ne sont pas des pices de 10 (1 5 +2 2 +1 = 1 10), pour un
total infrieur ou gal 9
Le nombre de pices de 10 est donc
S
10
|
Conclure avec ce qui prcde
Remarque : lalgorithme glouton nest pas optimal pour le jeu de pices de valeurs (6, 4, 1) :
pour S = 8, le glouton renvoie 8 = 6 + 1 + 1 alors quon a 8 = 4 + 4.
Dans le cas gnral, on cherche m(S), le nombre minimum de pices pour faire S avec des
pices de valeur (a
1
, a
2
, . . . , a
n
). Pour cela on introduit la fonction z telle que :
z(T, i) = nombre minimum de pices choisies parmi les i premires (a
1
, ..., a
i
) pour faire
T
on remarque que z(S, n) = m(S), on rsout un problme apparemment plus compliqu
que le problme de dpart
Mais on a une relation de rcurrence :
z(T, i) = min
_
z(T, i 1) i-me pice non utilise
z(T v
i
, i) + 1 on a utilis une fois (au moins) la i-me pice
Il faut initialiser la rcurrence correctement, par exemple en posant z(T, i) = 0 pour T 0 ou
i = 0.
Comment calculer toutes les Sn valeurs de z dont on a besoin ? Un algorithme qui calcule par
colonnes (boucle sur i externe, boucle sur T interne) permet de respecter les dpendances, i.e. de
toujours avoir en membre droit des valeurs prcdemment obtenues. On obtient une complexit
35
en O(n S)., alors que lalgorithme glouton avait une complexit en O(nlog n) (lexcution est
linaire, mais il faut auparavant trier les valeurs).
Remarque Caractriser les jeux de pices pour lesquels lalgorithme glouton est optimal est
un problme ouvert. Il est facile de trouver des catgories qui marchent (par exemple des pices
1, B, B
2
, B
3
, . . . pour B 2) mais le cas gnral rsiste !
3.2 Le problme du sac dos
On se donne n objets ayant pour valeurs c
1
, . . . , c
n
et pour poids (ou volume) w
1
, . . . , w
n
.
Le but est de remplir le sac dos en maximisant

iI
c
i
, sous la contrainte

iI
w
i
W, o
W est la contenance maximale du sac
3.2.1 En glouton
On va travailler sur le rapport qualit/prix. On commence par trier les objets selon les
c
i
w
i
dcroissants, puis on gloutonne en remplissant le sac par le plus grand lment possible chaque
tour.
Question : Est-ce optimal ? Non.
Le problme qui se pose est que lon travaille avec des lments discrets non divisibles.
Prenons un contre-exemple : si lon considre 3 objets, le 1er (c
i
/w
i
max) remplissant le sac
lui seul (aucun autre objet ne rentre) et les 2me et 3me tels que c
1
> c
2
, c
1
> c
3
, mais que
c
2
+c
3
> c
1
et que les deux objets puissent rentrer ensemble dans le sac. Alors la solution donne
par glouton (remplissage par le premier objet) est sous-optimale, contrairement au remplissage
par les objets 2 et 3.
(W = 10) (w
1
= 6; w
2
= 5; w
3
= 5) (c
1
= 7; c
2
= 5; c
3
= 5)
est un exemple dun tel cas de gure.
3.2.2 Par programmation dynamique
An de rsoudre le problme par une rcurrence, on va le compliquer. Un problme de rem-
plissage plus complexe que celui de dpart est celui o la taille du sac et le nombre dobjets
employer sont arbitraires. Posons alors C(v, i) comme lexpression du meilleur cot pour remplir
un sac de taille v avec les i premiers objets. Rsoudre le problme de remplissage du sac de taille
W avec les n objets revient donner C(W, n).
La rcurrence : soit on a pris le dernier objet, soit on ne la pas pris, do
C(v, i) = max
_
C(v, i 1) dernier objet non considr
C(v w
i
, i 1) +c
i
dernier objet pris
La solution optimale des sous-problmes va servir retrouver la solution optimale du pro-
blme global, sans que lon calcule jamais 2 fois la mme valeur. Ceci implique par contre de
respecter les dpendances du calcul.
Remarque Le cot de glouton est en O(nlog n) (tri de n nombres) tandis que le cot du
traitement en programmation dynamique est en O(nW)
36
w
v v!wi
i!1
i
n
C (v,i)
C (v, i!1)
C (v!wi, i!1)
Fig. 3.1 Attention au respect des dpendances !
3.3 Quelques exemples de programmation dynamique
Les exemples que nous allons voir ici concernent le traitement de chanes de matrices dune
part, et la dtermination de la plus longue sous-suite de deux chanes de caractres dautre part.
Credo du programmeur dynamique : Demain est le premier jour du reste de ta vie.
3.3.1 Chanes de matrices
Considrons n matrices A
i
, de taille P
i1
P
i
On veut calculer A
1
A
2
. . . A
n
. Le
problme que lon se pose est de trouver comment parenthser cette expression, le parenthsage
inuant sur les calculs.
Le nombre de parenthsages dirents peut se calculer par rcurrence. Soit C
n
le nombre de
parenthsages. Si lon place la dernire parenthse en k, on obtient si n 2 :
C(n) =
n1

k=1
C(k) C(n
k
)
On comprend intuitivement que le nombre de faons de parenthser dpend de la faon dont les
deux parties de lexpression ont t elles-mmes parenthses. La condition initiale est C(1) = 1.
Knuth nous explique que lon peut calculer C(n) par lintermdiaire des nombres de Catalan
(obtenus par sries gnratrices
1
). On a C(n) =
1
n
C
n1
2n2
= (4
n
/n
1.5
). Cette quantit earante
nous fait bien vite dchanter, et lon se rsout abandonner la stratgie de la force brute.
Pourquoi faire simple quand on peut faire compliqu ? Tchons de nous ramener de la
programmation dynamique (aprs tout cest le titre de ce paragraphe). Nous cherchions paren-
thser A
1
, . . . , A
n
, cherchons donc le cot optimal du parenthsage de A
i
, . . . , A
j
(not C(i, j)).
La solution de notre problme sobtiendra pour i = 1 et j = n.
La rcurrence :
Supposons que la meilleure faon de couper (A
i
, . . . , A
j
) est de couper un endroit k :
(A
i
. . . A
k
)
. .
cot optimal pour lobtenir : C(i, k)

cot optimal pour lobtenir : C(k + 1, j)


..
(A
k+1
. . . A
j
)
1
En cas de besoin urgent de compulser une rfrence sur les sries, se rfrer Flajeolet et Sedgewick
37
Le cot total dun parenthsage en k est donc de
C(i, k) +C(k + 1, j) + cot du produit des 2 membres (P
i1
P
k
P
j
)
et le cot optimal sobtient par
min
j1
k=i
{C(i, k) +C(k + 1, j) + (P
i1
P
k
P
j
)}
Le calcul se fait en respectant les dpendances : le calcul de C(i, j) demande tous les C(i, k)
et tous les C(k + 1, j)
i
j
C (i, j) C (k+1, j)
C (i,k)
Fig. 3.2 Linitialisation se fait sur C(i, i +1) = P
i1
P
i
P
i+1
et C(i, i) = 0 sur la diagonale
Lalgorithme ralisant le calcul en respectant les dpendances sera en O(n
3
) (for diag = ...
for lment dans diag calcul for k = ...)
Question :
Cet algorithme peut-il scrire en rcursif ? Oui.
Cela demande t-il plus de calcul ? Non, condition de sarrter lentre dun calcul C(i, j)
dj eectu. On initialise toutes les valeurs de C(i, j) +, et on eectue un test lentre
de lappel rcursif.
3.3.2 Plus longue sous-suite
Exemple : Votre petit frre apprend langlais avec un logiciel qui demande What is the
capital of the USA?. Il serait intressant que le logiciel soit capable de direncier New-York
de Washington mal crit, pour donner une rponse approprie (mauvaise rponse ou mauvaise
orthographe).
On peut alors dnir une mesure de distance ddition, cest dire le nombre de transformations
ncessaires pour passer dune chane une autre.
Soient
A = a
1
...a
n
B = b
1
...b
m
On dnit une sous-chane de A comme tant a
i
1
a
i
2
...a
i
k
.
On recherche les sous-chanes communes A et B, et plus particulirement la Plus Longue
Sous-Chane Commmune ou PLSCC.
Exemple :
A = aabaababaa, B = ababaaabb
alors PLSCC = ababaaa, non conscutifs.
38
Solution exhaustive
On essaie toutes les sous-suites : on numre les 2
n
sous-suites dans chaque chane, puis on
les compare. Sans doute peu ecace.
Programmation dynamique
On cherche la plus longue sous-chane commune entre les mots A et B, de longueurs respec-
tives n et m. On recherche :
PLSCC(n, m) :
_
A[1 . . . n]
B[1 . . . m]
Pour cela, on utilise la plus longue sous-chane commune entre les i et j premires lettres de A
et B respectivement, soit :
PLSCC(i, j) = p(i, j) :
_
A[1 . . . i]
B[1 . . . j]
On peut alors enclencher une rcurrence pour rsoudre le problme de la recherche de p(i, j).
p(i, j) = max
_
_
_
p(i, j 1)
p(i 1, j)
p(i 1, j 1) + [a
i
= b
j
] avec [a
i
= b
j
] vaut 1 si a
i
= b
j
, 0 sinon
Preuve
On constate dabord que :
max
_
_
_
p(i, j 1)
p(i 1, j)
p(i 1, j 1) + [a
i
= b
j
]
p(i, j)
Trivial en eet car p(i, j) est croissant valeurs entires en i et en j.
On peut diviser la preuve de lgalit en deux cas : soit (1) p
i
,= p
j
, soit (2) p
i
= p
j
.
1. Si p
i
,= p
j
, p
i
et p
j
ne peuvent pas appartenir tous deux la mme sous-suite commune :
on a donc deux cas : soit p
i
appartient la sous-suite et p(i, j) = p(i, j 1), soit cest p
j
qui y appartient, et on a p(i, j) = p(i 1, j).
2. Si p
i
= p
j
, deux cas se prsentent nouveau : soit la PLSCC contient p
i
= p
j
, et alors
p(i, j) = p(i1, j1)+1, soit elle ne contient pas p
i
= p
j
et donc p(i, j) = p(i1, j1)+0.
On a donc prouv la relation de rcurrence.
Exemple
A = a b c b d a b
B = b d c a b a
La PLSCC trouve est bdab : dans la Figure 3.3, on trouve une lettre commune lorsque les
ches sont diagonales. En eet, lalgorithme consiste prendre loption qui maximise le score,
cest dire le maximum de la pente.
Le cot de la recherche de la plus longue sous-chane commune est de O(nm). Il existe de
meilleurs algorithmes dans la littrature, de deux types :
les algorithmes qui sont ecaces lorsque les squences sont ressemblantes
les algorithmes qui sont ecaces lorsque les squences sont trs direntes.
On trouve alors des algorithmes en O((nr)m) ou en O(rm), avec r la longueur de la PLSCC
de deux mots de longueurs n et m.
39
Fig. 3.3 La PLSCC est bdab.
3.3.3 Location de skis
Voici un exercice trs joli, pour lequel il est conseill de chercher la solution avant de lire la
rponse !
Allocation de skis aux skieurs Spcier un algorithme ecace pour une attribution opti-
male de m paires de skis de longueur s
1
, . . . , s
m
, respectivement, n skieurs (m n) de
taille h
1
, . . . , h
n
, respectivement, via une fonction (injective) f : {1, . . . , n} {1, . . . , m},
f tant optimale lorsquelle minimise

n
k=1
|s
f(k)
h
k
|. On donne lindication suivante :
soit A[n, m] ce minimum. Dnir A[i, j] pour des valeurs plus petites i n et j m
(lesquelles ?), par une quation de rcurrence (i et j font rfrence aux i premiers skieurs
et aux j premires paires de skis, respectivement).
Complexit Analyser la complexit (en veillant aner lanalyse de sorte garantir que
lalgorithme soit en O(nlog n) si m = n).
Grand choix de skis Montrer quon peut avoir une meilleure complexit lorsque n
2
= o(m).
(Indication : se restreindre O(n
2
) paires de skis).
Allocation de skis aux skieurs On considre le mme problme, mais en ne prenant que
les i premiers skieurs et les j premires paires de skis (avec videmment les mmes longueurs et
tailles). Pour crire la rcurrence dnissant A[i, j], on est naturellement amen sintresser
la j-me paire de skis et au i-me skieur. Il y a deux cas. Si la solution optimale pour i, j nutilise
pas la j-me paire de skis, alors A[i, j] = A[i, j 1]. Si la j-me paire de skis est utilise, il est
tentant de laecter au i-me joueur. On fait dsormais lhypothse que les suites s
1
, . . . , s
m
et
h
1
, . . . , h
n
sont ranges dans lordre croissant, ou plus prcisment lont t dans une premire
phase de lalgorithme. On a la proprit suivante :
Lemme 1. (P) Si f : {1, . . . , i} {1, . . . , j} (injective) est telle quil existe i
1
i avec
f(i
1
) = j, alors

i
k=1
|s
f(k)
h
k
|

i
k=1
|s
f

(k)
h
k
|, avec f

obtenue partir de f en changeant


les images de i
1
et i (donc f

(i
1
) = f(i), f

(i) = j et f

= f ailleurs).
Preuve. Intuitivement, la proprit (P) dit que si on a une attribution avec deux paires de
ski pour deux skieurs donns, mieux vaut (plus exactement on ne perd rien ) attribuer la plus
petite paire au plus petit skieur et la plus grande paire au plus grand skieur. On pose
j
1
= f(i) A = |s
j
h
i
1
| + |s
j
i
h
i
| B = |s
j
1
h
i
1
| + |s
j
h
i
| .
40
Il faut montrer AB 0. On examine les direntes positions relatives de s
j
1
, s
j
, h
i
1
et h
i
.
s
j
1
h
i
1
h
i
s
j
: AB = (s
j
h
i
1
+h
i
s
j
1
) (h
i
1
s
j
1
+s
j
h
i
)
= 2(h
i
h
i
1
) 0
s
j
1
h
i
1
s
j
h
i
: AB = (s
j
h
i
1
+h
i
s
j
1
) (h
i
1
s
j
1
s
j
+h
i
)
= 2(s
j
h
i
1
) 0
s
j
1
s
j
h
i
1
h
i
: AB = (h
i
1
s
j
+h
i
s
j
1
) (h
i
1
s
j
1
+h
i
s
j
)
= 0
(On a omis les cas h
i
1
s
j
1
h
i
s
j
et h
i
1
h
i
s
j
1
s
j
qui sont similaires.)
Par la proprit (P), on peut supposer que le i-me skieur se voit attribuer la j-me paire
de skis. En eet, si ce nest pas le cas pour f, alors f

tel que dni plus haut est meilleure


que f, donc est optimale aussi, et attribue la j-me paire de skis au i-me skieur. Et on a
A[i, j] = A[i 1, j 1] + |s
j
h
i
|. Au total, on a prouv :
A[i, j] = min(A[i, j 1], (A[i 1, j 1] + |s
j
h
i
|)) .
Lalgorithme consiste donc calculer ces A[i, j], et si lon veut calculer lattribution f en mme
temps, on note f(i) = j au passage si on est dans le deuxime cas.
Complexit Combien dentres A[i, j] faut-il calculer ? Il est facile de voir que les appels
rcursifs depuis A[n, m] laissent de ct les deux triangles gauche infrieur et droite suprieur
de la matrice (n, m) qui ensemble ont une dimension (n, n). Donc, ce ne sont pas nm, mais
(m n)n entres qui sont calculer. Si lon compte le temps du tri des deux suites, on arrive
donc une complexit
O((mlog m) + (nlog n) + (mn)n) .
Ceci est satisfaisant dans le cas particulier o m = n : on obtient alors O(mlog m), et en eet,
si m = n, il sut de trier les deux suites et de poser f = id (ce qui se voit par rcurrence en
utilisant la proprit (P)). (Noter que la complexit mal ane O(mlog m) + O(nlog n) + mn
aurait donn O(n
2
).)
Grand choix de skis On remarque que si les listes sont tries, on peut se contenter, pour
chaque skieur, de trouver la meilleure paire de skis et les n 1 meilleures paires de skis aprs la
meilleure, de part et dautre de la meilleure longueur. Cette fentre S
i
de taille 2n1 permet de
prvoir les conits avec les autres skieurs. Plus prcisment, les paires de skis ainsi dtermines
reprsentent un ensemble S =

n
i=1
S
i
de n(2n 1) paires de skis avec de possibles rptitions
tel que lon peut dnir une injection f : {1, . . . , n} S avec f(i) S
i
pour tout i (choisir
successivement une paire de skis dirente pour chaque skieur, la marge de manoeuvre laisse
dau moins n 1 autres paires de skis pour chaque skieur garantit que cest possible). On peut
donc appliquer ltude du dbut n et cet ensemble S dont le cardinal est au plus n(2n1). Le
temps pris pour dterminer le sous-ensemble S est O(n((log m) +n)) : le premier n correspond
la recherche des S
i
successifs, log m est le temps pour dterminer la meilleure paire de skis (par
dichotomie dans la liste trie des s
i
), et le dernier n correspond la taille de la fentre autour
de la meilleure hauteur.
Il reste voir quune solution optimale pour ce sous-ensemble de paires de skis est optimale
pour lensemble de toutes les paires de skis. On remarque que pour tout j / S, on a par
construction que pour tout i il existe au moins n lments s
j
1
, . . . , s
jn
de S
i
tels que |s
j
h
i
|
41
|s
j
k
h
i
| (1 k n). (Noter ici limportance davoir pris des paires de part et dautre de la
meilleure paire de skis.) Si donc il existait une fonction dattribution optimale qui atteint j (ainsi
possiblement que dautres valeurs hors de S), on pourrait remplacer sans conit (cf. ci-dessus)
ces valeurs par des valeurs de S, et donc obtenir une autre fonction optimale valeurs dans S.
La complexit relative n et S sexprime comme suit (en y incorporant le temps de recherche
des lments de S) :
O(n
2
log n) +O(nlog n) +O((n
2
n)n) +O(n((log m) +n)) = O(n
3
+nlog m) .
Ce temps est meilleur que le temps obtenu en (A2) si n
2
= o(m), car alors O(n
3
+ nlog m) =
o((mlog m) + (nlog n) + (mn)n). En eet, (nlog m)/(mlog m) et n
3
/(mn)n tendent vers
0 (noter quon a fortiori n = o(m)).
3.4 Exercices
Exercice 3.4.1. Triangulation de polygones
On considre les polygones convexes du plan. Une triangulation dun polygone est un en-
semble de cordes qui ne se coupent pas lintrieur du polygone et qui le divisent en triangles.
1 - Montrer quune triangulation dun polygone n cts a (n 3) cordes et (n 2) triangles.
2 - Le problme est celui de la triangulation optimale de polygones. On part dun polygone
convexe P = v
0
, ..., v
n
), o v
0
, . . . , v
n
sont les sommets du polygone donns dans lordre direct,
dnie sur les triangles forms par les cts et les cordes de P (par exemple w(i, j, k) = |v
i
v
j
|+
|v
j
v
k
|+|v
k
v
i
| est le primtre du triangle v
i
v
j
v
k
). Le problme est de trouver une triangulation
qui minimise la somme des poids des triangles de la triangulation.
On dnit pour 1 i < j n, t[i, j] comme la pondration dune triangulation optimale du
polygone v
i1
, ..., v
j
), avec t[i, i] = 0 pour tout 1 i n.
Dnir t rcursivement, en dduire un algorithme et sa complexit.
3 - Si la fonction de poids est quelconque, combien faut-il de valeurs pour la dnir sur tout
triangle du polygone ? Comparez avec la complexit obtenue.
4 - Si le poids dun triangle est gal son aire, que pensez-vous de lalgorithme que vous avez
propos ?
Correction.
1- On procde par rcurrence sur n 3.
Pour n = 3, le polygne est un triangle, qui a bien n 2 = 1 triangle et n 3 = 0 corde.
Soit n N, n 3. On suppose le rsultat dmontr pour tout polygne convexe possdant un
nombre de cts strictement infrieur n. Soit alors un polygne n cts et une triangulation
de ce polygne. Considrons une corde qui divise ce polygne en deux polygnes, respectivement
(i + 1) et (j + 1) cts avec i +j = n, i 2, j 2 (comme le montre la gure 3.4).
Par hypothse de rcurrence, on a (i 2) cordes dans le premier polygne et j 2 dans le
second, ce qui fait pour le polygne entier (i 2) + (j 2) + 1 = n 3 cordes en tout (le +1
reprsente la corde qui sparait le polygne en deux).
De mme, on obtient un total de (i 1) +(j 1) = n2 triangles dans le polygne en tout,
ce qui achve la dmonstration.
2- Pour trouver une formule de rcurrence sur t, il sut de saperevoir que le v
i1
v
j
fait partie dun triangle dont le troisime sommet est v
k
. On en dduit la formule : t[i, j] =
42
i + 1 cts
j + 1 cts
Fig. 3.4 Une corde (en bleu) qui divise un polygone en deux
min
ikj1
(t[i, k]+t[k+1, j]+w(i1, k, j)) (On remarque que la convention t[i, i] est bien adap-
te puisque la formule ci-dessus reste vraie quand j = i+1 : on a bien t[i, i+1] = w(i1, i, i+1).).
Nous pouvons maintenant crire un algorithme qui calcule t[1, n], et ce partir des t[k, j], i +
1 k j et des t[i, k], i k j 1, cest dire, si lon reprsente les valeurs calculer dans un
diagramme (i, j) comme celui donn dans la gure 3.5, partir des valeurs situes en-dessous
et droite du point (1, n). On saperoit alors quil sut de calculer les t[i, j] pour i de 1 n
et pour j i, et ce par (j i) croissant.
0
n
n
t[i,j]
1
1
j
i
t[1,n]
Fig. 3.5 Diagramme (i, j) des valeurs calculer par lalgorithme de rsolution
43
Ceci donne lalgorithme :
dbut
pour i de 0 n faire
t[i, i] 0
pour d de 1 n 1 faire
pour i de 1 n d faire
t[i, i +d] min
ikj1
(t[i, k] +t[k + 1, j] +w(i 1, k, j))
Retourner t[1, n]
n
Cet algorithme calcule t[i, j] en 2(j i) additions et en j i 1 comparaisons pour calculer le
min.
Le nombre total dadditions est donc : A
n
=

n1
d=1
((n d) (2d)) o (n d) correspond au
nombre de t[i, j] calculer sur la diagonale j i = d et 2d au nombre dadditions dans le calcul
de chaque t[i, j] o j i = d, ce qui nous donne :
A
n
= 2n
n1

d=1
d 2
n1

d=1
d
2
= 2n
n (n 1)
2
2
(n 1) n (2n 1)
6
=
(n 1) n (n + 1)
3
n
3
/3 = (n
3
)
Pour calculer le nombre T
n
de tests eectuer, il sut de remarquer quon fait deux fois
moins de tests que dadditions dans le calcul du minimum, ce qui nous donne T
n
= A
n
/2 C
n
o C
n
reprsente le nombre total de t[i, j] calculs (ie le nombre daectations) On en dduit :
T
n
= A
n
/2
n1

d=1
(n p)
= (n
3
)
La complexit globale de lalgorithme est donc en (n
3
).
3- Dans le cas gnral, il faut autant de valeurs pour dnir la fonction w quil ny a de
triangles possibles, soit C
3
n+1
= (n
3
). Comme il faudra bien lire chacune de ces valeurs pour
construire une triangulation optimale, nimporte quel algorithme doit fonctionner en une com-
plexit dau moins (n
3
). Notre algorithme est donc optimal en complexit du point de vue de
lordre de grandeur.
4- Dans le cas o le poids dun triangle est gal son aire, toutes les triangulations donnent
le mme poids qui est laire du polygne. Lalgorithme prcdent est donc inadapt, et on peut
la place procder par exemple comme suit :
Algorithme
Prendre une triangulation quelconque (par exemple avec les cordes (v
0
v
i
)
2in1
).
Faire la somme des poids des triangles.
Cet algorithme neectue aucun test et n 3 additions (bien en dessous du (n
3
) !).
44
Exercice 3.4.2. Jeu de construction
On veut construire une tour la plus haute possible partir de direntes briques. On dispose
de n types de briques et dun nombre illimit de briques de chaque type. Chaque brique de
type i est un paralllpipde de taille (x
i
, y
i
, z
i
) et peut tre oriente dans tous les sens, deux
dimensions formant la base et la troisime dimension formant la hauteur.
Dans la construction de la tour, une brique ne peut tre place au dessus dune autre que si
les deux dimensions de la base de la brique du dessus sont strictement infrieures aux dimensions
de la base de la brique du dessous.
Proposer un algorithme ecace pour construire une tour de hauteur maximale.
Correction.
Si on prend un paralllpipde quelconque (x
i
, y
i
, z
i
), on saperoit quon peut le poser sur la
tour de 6 manires direntes.
On peut commencer par remarquer que si on peut poser une brique sur une autre de faon
ce que la longueur de la 1
re
brique soit parallle la largeur de la 2
e
, alors on peut aussi
poser la 1
re
brique sur la 2
e
de faon ce que les largeurs (et donc aussi les longueurs) des deux
briques soient parallles (comme le montre la gure 3.6). On peut donc faire lhypothse que
les briques seront poses les unes sur les autres de telle sorte que les largeurs des briques soient
toutes parallles entre elles. (Le nombre de congurations par paralllpipde est ainsi rduit
3.)
Remarquons ensuite quun mme paralllpipde ne peut tre utilis au plus que deux fois
(dans deux congurations direntes). En eet, considrons le paralllpipde (x
i
, y
i
, z
i
) avec
x
i
y
i
z
i
: si on la pose une premire fois, alors, dans le meilleur des cas, on peut encore
poser sur la tour toutes briques (x
j
, y
j
, z
j
) telles que x
j
< y
i
et y
j
< z
i
(en supposant que
x
j
y
j
z
j
). Ainsi, si les ingalits sont strictes pour x
i
, y
i
, et z
i
, on peut encore poser le
paralllpipde. Pour le poser une troisime fois, il faudrait quil possde un ct de longueur
strictement infrieure x
i
. Ce nest pas le cas, est donc on ne peut le poser que deux fois. Cela a
pour consquence que la tour de hauteur maximale sera compose dau plus 2n paralllpipdes.
Dornavant, nous allons considrer les briques (L
i
, l
i
, h
i
) avec L
i
l
i
. Nous devons alors
considrer 3n briques au lieu de n paralllpipdes, mais il ne reste plus quune conguration
possible par brique ( Si le paralllpipde est (x
i
, y
i
, z
i
) avec x
i
< y
i
< z
i
, les 3 briques associes
sont (z
i
, y
i
, x
i
), (z
i
, x
i
, y
i
) et (y
i
, x
i
, z
i
).).
Ainsi, on peut poser la brique (L
i
, l
i
, h
i
) sur la brique (L
j
, l
j
, h
j
) si et seulement si
_
L
i
< L
j
l
i
< l
j
On pose i {1, . . . , 3n}, H
i
= hauteur maximale parmi les tours se terminant par la i
e
Fig. 3.6 Si une brique pose sa largeur parallle la longueur de celle en dessous, alors elle
peut tre pose de telle sorte que leurs longueurs sont parallles
45
brique. On a la relation de rcurrence suivante :
i {1, . . . , 3n}, H
i
= h
i
+Max
1j3n
(H
j
/L
j
> L
i
et l
j
> l
i
) (3.1)
Lide est de commencer par trier les 3n briques par (L
i
, l
i
) dcroissant. Cel se fait en
O(nlog(n)) comparaisons. Lquation prcdente peut alors se rcrire :
i {1, . . . , 3n}, H
i
= h
i
+Max
1j<i
(H
j
/L
j
> L
i
et l
j
> l
i
) (3.2)
On calcule ainsi chaque H
i
pour i allant de 2 3n en partant de H
1
= h
1
. Le calcul
de H
i
ncessite 1 addition et 3i 3 comparaions dans le pire des cas. Le calcul de tous les
H
i
, i 1, . . . , 3n est donc linaire en addition et quadratique en comparaison.
Enn, il faut calculer H = Max
1i3n
(H
i
) qui est la solution de notre problme, ce qui cote
3n 1 comparaisons. La complexit totale est par consquent en O(n
2
) pour les comparasions
et en O(n) pour les additions et lalgorithme est le suivant :
dbut
liste []
pour i de 1 n faire
Ajouter les 3 congurations possibles du paralllpipde (x
i
, y
i
, z
i
) liste
Trier liste = (L
i
, l
i
, h
i
)
i{1,...,3n}
par (L
i
, l
i
) dcroissant.
H
1
h
1
pour i de 2 3n faire
H
i
h
i
+Max
1j<i
(H
j
/L
j
> L
i
et l
j
> l
i
)
H Max
1i3n
(H
i
)
Renvoyer H
n
Exercice 3.4.3. Plus grand carr de 1
Donner un algorithme de programmation dynamique pour rsoudre le problme suivant :
Entre : une matrice A de taille n m o les coecients valent 0 ou 1.
Sortie : la largeur maximum K dun carr de 1 dans A, ainsi que les coordonnes (I, J)
du coin en haut gauche dun tel carr (autrement dit pour tout i, j, I i I + K 1,
J j J +K 1, A[i, j] = 1).
Quelle est sa complexit ?
Indication : considrer t[i, j] la largeur du plus grand carr de 1 ayant (i, j) pour coin en haut
gauche.
6
4
5
7
3
2
1
2 3 4 5 6 7 8 1 9
A
0
0
1 1
1 1 1 1
1 1
1
1
1
1
1
1
1
1 0
0
0
0
0
1
0 0 0
0
0
0 0 0 0 0 0 0
0
0 0
0 0
0 0 0 0 0
0
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
Fig. 3.7 Exemple o la largeur max. dun carr de 1 vaut 4 ((2, 3) est le coin en haut gauche).
46
1
x
Fig. 3.8 schma des carrs prendre en compte pour le calcul de t[i, j]
Correction.
On considre la matrice A de taille n m dont les coecients valent 0 ou 1, et on note C
i,j
le
plus grand carr ayant llment A
i,j
comme coin suprieur gauche, et t[i, j] sa largeur. On peut
alors tablir la relation de rcurrence suivante :
i, j < n, m
_
si A
i,j
= 0, t[i, j] = 0
sinon, t[i, j] = min(t[i, j + 1], t[i + 1, j], t[i + 1, j + 1]) + 1
En eet, le premier cas se vrie de manire triviale, et lon peut vrier le second cas, en
remarquant dj que lon a t[i + 1, j + 1] max(t[i, j + 1], t[i + 1, j]) 1. Ensuite, si lon pose
l = t[i, j + 1] et que lon a l < t[i + 1, j] t[i + 1, j + 1] 1, alors A
i,j+l+1
= 0 et donc
t[i, j] l + 1. Do, le carr de coin suprieur gauche A
i,j
et de ct l + 1 est inclu dans
lensemble C
i,j+1
C
i+1,j
{A
i,j
}, il est donc entirement constitu dlments valant 1. On
procede de la mme manire si t[i +1, j] < t[i, j +1], ce qui permet de vrier la formule donne
prcdemment. Dans le cas o t[i + 1, j] = t[i, j + 1] = l, on a t[i, j] = l + 1 si A
i+l,j+l
= 1 (et
dans ce cas t[i +1, j +1] l) mais sinon, on a t[i, j] = l 1 (et dans ce cas t[i +1, j +1] = l 1).
On retrouve bien notre formule. Tout ceci nous fournit lalgorithme suivant :
/* initialisation des bords de la matrices */
pour i de 1 n faire t[i, m] A
i,m
pour j de 1 m faire t[n, j] A
n,j
/* calcul des t[i,j] dans le bon ordre */
pour i de n 1 1 faire
pour j de m1 1 faire
si A
i,j
= 0 alors faire t[i, j] 0
sinon faire t[i, j] min(t[i, j + 1], t[i + 1, j], t[i + 1, j +
1]) + 1
retourner max
i,j
t[i, j]
Exercice 3.4.4. Arbres binaires de recherche optimaux
Un arbre binaire de recherche est une structure de donnes permettant de stocker un ensemble
de cls ordonnes x
1
< x
2
< . . . < x
n
, pour ensuite eectuer des oprations du type rechercher,
insrer ou supprimer une cl. Il est dni par les proprits suivantes :
(i) Cest un arbre o chaque nud a 0, 1 ou 2 ls, et o chaque nud stocke une des cls.
47
(ii) Etant donn un nud avec sa cl x, alors les cls de son sous-arbre gauche sont strictement
infrieures x et celles de son sous-arbre droit sont strictement suprieures x.
La gure 3.9 reprsente un arbre binaire de recherche pour les cls x
1
< x
2
< x
3
< x
4
<
x
5
< x
6
< x
7
< x
8
< x
9
.
x
7
x
6
x
9
x
5
x
4
x
2
x
8
x
3
x
1
profondeur 0
profondeur 1
profondeur 2
profondeur 3
Fig. 3.9 Exemple darbre binaire de recherche.
Les requtes auxquelles on sintresse ici sont les recherches de cls. Le cot de la recherche
dune cl x correspond au nombre de tests eectus pour la retrouver dans larbre en partant de
la racine, soit exactement la profondeur de x dans larbre, plus 1 (la racine est de profondeur 0).
Pour une squence xe de recherches, on peut se demander quel est larbre binaire de
recherche qui minimise la somme des cots de ces recherches. Un tel arbre est appel arbre
binaire de recherche optimal pour cette squence.
1 - Pour un arbre binaire de recherche x, le cot de la squence ne dpend clairement que du
nombre de recherches pour chaque cl, et pas de leur ordre. Pour n = 4 et x
1
< x
2
< x
3
< x
4
,
supposons que lon veuille accder une fois x
1
, 9 fois x
2
, 5 fois x
3
et 6 fois x
4
. Trouver
un arbre binaire de recherche optimal pour cet ensemble de requtes.
2 - Donner un algorithme en temps O(n
3
) pour construire un arbre binaire de recherche optimal
pour une squence dont les nombres daccs aux cls sont c
1
, c
2
, . . . , c
n
(c
i
est le nombre de fois
que x
i
est recherch). Justier sa correction et sa complexit.
Indication : pour i j, considrer t[i, j] le cot dun arbre de recherche optimal pour les cls
x
i
< ... < x
j
accdes respectivement c
i
, . . . , c
j
fois.
Correction.
1 - Arbres binaires optimaux
il sut de dessiner lensemble des graphes possibles (il y en a 14) pour trouver les deux
graphes minimaux.
x4
x2
x3
x1 x4
x3
x2
x1
48
2 - Algorithme
Le poids dun arbre est le poid de ses ls, plus le poids de sa racine, plus le poids de tous
les noeuds de ses ls (on leur rajoute un niveau). On appelle t[i, j] le poid de larbre, de poids
minimum contenant les sommets de i j, et C
k
le poid du sommet p. donc :
t[i, j] = min
ikj
(t[i, k 1] +C
k
+t[k + 1, j] +
k1

p=i
(C
p
) +
j

p=k+1
(C
p
))
soit :
t[i, j] = min
ikj
(t[i, k 1] +t[k + 1, j]) +
j

p=i
(C
p
)
On initialise lalgo avec t[i, i 1] = 0.
c(k+1,j)
c(i,k)
c(i,j)
j
i
la complexit est en O(n
3
) : une boucle sur les i une autre sur les j puis une dernire sur les
k.
Exercice 3.4.5. Impression quilibre
Le problme est limpression quilibre dun paragraphe sur une imprimante. Le texte den-
tre est une squence de n mots de longueurs l
1
,l
2
,...,l
n
(mesures en caractres). On souhaite
imprimer ce paragraphe de manire quilibre sur un certain nombre de lignes qui contiennent
un maximum de M caractres chacune. Le critre dquilibre est le suivant.
Si une ligne donne contient les mots i j (avec i j) et quon laisse exactement un espace
entre deux mots, le nombre de caractres despacement supplmentaires la n de la ligne est
Mj +i

j
k=i
l
k
, qui doit tre positif ou nul pour que les mots tiennent sur la ligne. Lobjectif
est de minimiser la somme, sur toutes les lignes hormis la dernire, des cubes des nombres de
caractres despacement prsents la n de chaque ligne.
1 - Est-ce que lalgorithme glouton consistant remplir les lignes une une en mettant chaque
fois le maximum de mots possibles sur la ligne en cours, fournit loptimum?
49
2 - Donner un algorithme de programmation dynamique rsolvant le problme. Analyser sa
complexit en temps et en espace.
3 - Supposons que pour la fonction de cot minimiser, on ait simplement choisi la somme des
nombres de caractres despacement prsents la n de chaque ligne. Est-ce que lon peut faire
mieux en complexit que pour la question 2 ?
4 - (Plus informel) Quest-ce qui votre avis peut justier le choix de prendre les cubes plutt
que simplement les nombres de caractres despacement en n de ligne ?
Correction.
Laisse au lecteur.
3.5 Rfrences bibliographiques
La prsentation du cours et les exercices sinspirent du Cormen [2].
50
Chapitre 4
Algorithmes gloutons
4.1 Exemple du gymnase
Problme
On considre un gymnase dans lequel se droulent de nombreuses preuves : on souhaite en
caser le plus possible, sachant que deux vnements ne peuvent avoir lieu en mme temps (il
ny a quun gymnase). Un vnement i est caractris par une date de dbut d
i
et une date de
n f
i
. On dit que deux vnements sont compatibles si leurs intervalles de temps sont disjoints.
On veut rsoudre le problme laide dun programme glouton.
Essai 1
On trie les vnements par dure puis on gloutonne, i.e. on met les plus courts en premier sils
sont compatibles avec ceux dj placs.
Ceci nest pas optimal comme le montre lexemple de la Figure 4.1.
j
k
i
Fig. 4.1 Lessai 1 ne conduit pas loptimal.
On constate que lvnement i, plus court que k et j, est plac avant ceux-ci et les empche
dtre choisis : on obtient alors une situation non optimale o seul un vnement a eu lieu alors
que deux vnements taient compatibles lun avec lautre.
Essai 2
Plutt que de trier par dure les vnements, on peut les classer par date de commencement.
Encore une fois, cet algorithme nest pas optimal, comme le montre lexemple de la Figure 4.2
j k l
m n o p q
i
Fig. 4.2 Lessai 2 ne conduit pas loptimal.
51
On constate que lvnement i, le premier dmarrer, empche toute une multitude dv-
nements davoir lieu : le second essai est loin dtre optimal.
Essai 3
On peut enn trier les vnements par date de n croissante.
Thorme 4. Cet algorithme glouton est optimal.
Preuve. Soit f
1
llment nissant le plus tt. On va montrer quil existe une solution optimale
contenant cet vnement. Soit donc une solution optimale arbitraire O,
O = {f
i
1
, f
i
2
, ..., f
i
k
}
avec k le maximum dvnements pouvant avoir lieu dans le gymnase. Il y a deux possibilits :
soit f
i
1
= f
1
soit f
i
1
,= f
1
. Dans ce dernier cas, alors on remplace f
i
1
par f
1
. Comme f
1
nit avant
tout autre vnement, alors comme f
i
2
nintersectait pas avec f
i
1
, f
i
2
nintersecte pas avec f
1
.
On peut donc bien trouver une solution optimale ayant comme premier vnement lvnement
nissant en premier, la classe des solutions ayant f
1
en premier domine.
Ensuite, aprs avoir plac f
1
, on ne considre que les vnements nintersectant pas avec f
1
, et
on ritre la procdure sur les vnements restants, do la preuve par rcurrence.
4.2 Coloriage dun graphe
Soit un graphe G = (V, E) (en anglais vertex=sommet et edge=arte). On veut colorier
les sommets, mais deux sommets relis par une arte ne doivent pas avoir la mme couleur :
formellement, on dnit la coloration c : V {1..K} telle que (x, y) E c(x) ,= c(y). Le but
est de minimiser K, le nombre de couleurs utilis
Thorme 5. Un graphe est 2-coloriable ssi ses cycles sont de longueur paire.
Preuve. = Supposons que G contienne un cycle de longueur impaire 2k + 1, et que, par
labsurde, il soit 2-coloriable. Pour les sommets du cycle, si 1 est bleu, alors 2 est rouge et par
rcurrence les impairs sont bleus et les pairs rouges ; mais 1 est ct de 2k +1. Contradiction.
= Supposons que tous les cycles de G soient de longueur paire. On suppose que G est
connexe (le problme est indpendant dune composante connexe lautre). On parcourt G en
largeur.
Soit x
0
G, X
0
= {x
0
} et X
n+1
=

yXn
{ls de y dans lordre de parcours}.
Si par labsurde kmz X
2k
X
2m+1
, alors z est distance 2k de x
0
et 2m + 1 de x
0
. Le
cycle correspondant contient(2k 1) + (2m) + 2 = 2(m+k) + 1 lments. Contradiction.
Donc kmX
2k
X
2m+1
= ; on colorie en bleu les lments des X
i
avec i impair et en rouge
les lments des X
i
avec i pair.
Il ne peut y avoir deux lments relis appartenant X
i
,X
j
avec i et j de mme parit car sinon
ils formeraient en remontant x
0
un cycle de longueur i +j + 1 (impaire).
On a donc 2-colori G.
On appelle biparti un graphe 2-coloriable : les sommets sont partitionns en deux ensembles,
et toutes les artes vont dun ensemble lautre. On sintresse maintenant au coloriage dun
graphe gnral.
52
4.2.1 Algorithme glouton 1
Pour colorier un graphe gnral :
prendre les sommets dans un ordre au hasard ;
leur attribuer la plus petite valeur possible, i.e. la plus petite valeur qui na pas dj t
attribue un voisin.
Soit K le nombre de couleurs utilises. Alors K (G) + 1, o (G) est le degr maximal
dun sommet, le degr dun sommet tant le nombre dartes auxquelles appartient ce sommet.
En eet, au moment o on traite un sommet donn, il a au plus (G) voisins dj coloris, donc
lalgorithme glouton nest jamais forc dutiliser plus de (G) + 1 couleurs.
Pour une clique (un graphe complet, avec toutes les artes possibles), il nest pas possible de
faire mieux.
4.2.2 Algorithme glouton 2
trier les sommets par degr dcroissant ;
prendre les sommets dans cet ordre ;
leur attribuer la plus petite valeur possible.
Soit n = |V | le nombre de sommets, et d
i
le degr du sommet v
i
. On montre alors que
K max
1in
min(d
i
+ 1, i). En eet, au moment o on colorie le i-me sommet v
i
, il a
au plus min(d
i
, i 1) voisins qui ont dj t coloris, et donc sa propre couleur est au plus
1 + min(d
i
, i 1) = min(d
i
+ 1, i). En prenant le maximum sur i de ces valeurs, on obtient la
borne demande.
Cette borne suggre de se dbarrasser dabord des plus gros degrs, qui disparaissent ainsi de
la complexit tant que min(d
i
+1, i) = i. Comme on ne sait pas a priori jusqu quand privilgier
les grands degrs, on a tri lensemble des sommets par degrs dcroissants dans lalgorithme
glouton.
4.2.3 Graphe dintervalles
Lalgorithme glouton, avec un ordre astucieux, est optimal pour les graphes dintervalles.
Etant donne une famille dintervalles (disons sur la droite relle), on dnit un graphe dont les
sommets sont les intervalles, et dont les artes relient les sommets reprsentant les intervalles
qui sintersectent. Voici un exemple :
a d e
b
c
f
g
b
d
a g
f c e
On montre que lalgorithme glouton colorie le graphe de manire optimale si lon numre
les sommets dun graphe dintervalles G selon lordre donn par les extrmits gauches des
intervalles, savoir a, b, c, d, e, f, g sur lexemple.
Sur lexemple on obtient le coloriage 1, 2, 3, 1, 1, 2, 3 qui est bien optimal. Dans le cas gnral,
excutons lalgorithme glouton avec lordre spci des sommets. Supposons que le sommet v
reoive la couleur maximale k. Pourquoi v ne reoit-il pas une couleur plus petite ? Parce que
lextrmit de gauche a de son intervalle appartient aussi des intervalles qui ont dj reu les
couleurs 1 k 1. Ces intervalles ont donc tous le point a en commun, si bien que G possde
une clique (un sous-graphe complet) de taille k. Le cardinal maximal dune clique de G est
donc suprieur ou gal k. Comme tous les sommets dune clique doivent recevoir une couleur
53
dirente, on voit que lon ne peut pas faire mieux que k couleurs. Lalgorithme glouton est donc
optimal.
4.2.4 Algorithme de Brelaz
Lide intuitive est de colorier en priorit les sommets ayant beaucoup de sommets dj
coloris. On dnit le degr-couleur dun sommet comme son nombre de voisins dj coloris.
Le degr-couleur, qui va voluer au cours de lalgorithme, est initialis 0 pour tout sommet :
prendre parmi les sommets de degr-couleur maximal un sommet de degr maximal, et lui
attribuer la plus petite valeur possible.
Il sagit dun glouton sur (degr-couleur, degr), appel algorithme de Brlaz. Considrons
lexemple ci-dessous :
v v
1 2
v v
v v
4
3
5
6
v
7
On prend au dpart un sommet de degr maximal, par exemple v
1
, et on lui donne la couleur
1. Le degr-couleur de v
2
, v
5
, v
6
et v
7
passe 1, on choisit v
2
qui est de degr maximal parmi ces
trois sommets, et on lui donne la couleur 2. Maintenant, v
7
est le seul sommet de degr-couleur
2, on le choisit et on lui attribue la couleur 3. Tous les sommets restants (non coloris) ont le
mme degr-couleur 1 et le mme degr 3, on choisit v
3
au hasard, et on lui donne la couleur 1.
Puis v
4
, de degr-couleur 2, reoit la couleur 3. Enn v
5
reoit la couleur 2 et v
6
la couleur 3.
Le graphe est 3-colori, cest optimal.
Thorme 6. Lalgorithme de Brelaz est optimal sur les graphes bipartis, i.e. russit toujours
les colorier avec deux couleurs.
Preuve. On considre un graphe biparti G = (V, E), V = B R : toute arte de E relie un
sommet de B (bleu) et un sommet de R (rouge). Remarquons dabord que les deux premiers
algorithmes gloutons peuvent se tromper : par exemple soit G avec B = {b
1
, b
2
, b
3
}, R =
{r
1
, r
2
, r
3
}, et les six artes (b
i
, r
i
), 1 i 3, (b
1
, r
2
), (b
2
, r
3
) et (b
3
, r
1
). Tous les sommets sont
de degr 2. Si on commence par colorier un sommet de B, disons b
1
, puis un sommet non adjacent
de R, r
3
, avec la mme couleur 1, on ne pourra pas terminer avec seulement 2 couleurs. Par
contre, en utilisant la variante de Brelaz avec les degrs-couleur sur ce petit exemple, aprs b
1
on
doit colorier soit r
1
soit r
2
, et on ne se trompe pas. Pour le cas gnral, considrons G = (V, E),
V = BR connexe biparti, et colorions le avec lalgorithme de Brelaz. On commence par colorier
un sommet, disons, de B, en bleu. Puis on colorie ncessairement un sommet adjacent (de degr-
couleur 1), donc de R, en rouge. Par la suite, on ne colorie que des sommets de degr-couleur
gal 1, cest linvariant qui donne le rsultat.
Remarque Le problme du coloriage des graphes est NP-complet.
4.3 Thorie des matrodes
Petite thorie base sur les matrodes permettant de savoir si un algorithme glouton est
optimal pour un problme.
54
4.3.1 Matrodes
Dnition 1. (S, I) est un matrode si S est un ensemble de n lments, I est une famille de
parties de S, I P(S), vriant :
- lhrdit : X I Y X, Y I
- lchange :(A, B I, |A| < |B|) x B \ A tq A {x} I
Si X I, on dit que X est un indpendant.
Exemples
1. Les familles libres dun espace vectoriel
2. Les forts
1
dun graphe.
Soit G = (V, E) un graphe , |V | = n, on dnit alors S = E et I = {A E/A sans cycles},
c.a.d. quun ensemble dartes est un indpendant ssi cest une fort.
Lhrdit est vidente, car un sous-ensemble dune fort est une fort (en enlevant des
artes une fort on ne cre pas de cycles).
Lchange :
Soient A et B des forts de G tq |A| < |B|. Alors A (resp. B) contient n |A| (resp.
n |B|) arbres (avec chaque arte ajoute A, on relie deux arbres, donc on dcrmente
de un le nombre darbres de A).
Donc B contient moins darbres que A, il existe alors un arbre T de B qui nest pas inclus
dans un arbre de A, c.a.d. quil existe deux sommets u et v de T qui nappartiennent
pas au mme arbre de A. Sur le chemin de u v dans T, il existe une paire de sommets
conscutifs qui ne sont pas dans le mme arbre de A (ils sont de chaque ct du pont qui
traverse dun arbre de A lautre). Soit (x, y) larte en question. dou A {(x, y)} est
sans cycle, i.e. A {(x, y)} I
Dnition 2. Un indpendant est dit maximal sil est maximal au sens de linclusion
Lemme 2. Tous les indpendants maximaux ont mme cardinal.
(Si ce ntait pas le cas, on pourrait les tendre par la proprit dchange)
4.3.2 Algorithme glouton
Fonction de poids x S w(x) N; X S , w(X) =

xX
w(x)
Question Trouver un indpendant de poids maximal.
Par glouton : trier les lments de S par poids dcroissant.
A
2
For i = 1 to |S|
si A {s
i
} I alors A A {s
i
}
Thorme 7. Cet algorithme donne la solution optimale.
Preuve. Soit s
k
le premier lment indpendant de S, ie le premier indice i de lalgorithme
prcdent tel que {s
i
} I.
Lemme 3. Il existe une solution optimale qui contient s
k
.
1
Une fort est un ensemble darbres, i.e. un graphe non-orient sans cycles
2
est un indpendant, par lhrdit
55
En eet : Soit B une solution optimale, i.e. un indpendant de poids maximal et A la solution
renvoye par glouton, s
k
A,on a alors :
1. soit s
k
B, donc cest bon.
2. soit s
k
/ B, on applique |B| 1 fois la proprit dchange, do lindpendant A =
B\{b
i
} {s
k
}, o {b
i
} est llment restant de B (car |A| = |B| et A contient dj s
k
)
On a w(A) = w(B) w(b
i
) +w(s
k
), or w(s
k
) w(b
i
) car b
i
indpendant (par lhrdit)
et b
i
a t trouv aprs s
k
, par ordre dcroissant.
Donc w(A) w(B), do w(A) = w(B), A optimal.
Puis, par rcurrence on obtient que glouton donne la solution optimale : on se restreint
une solution contenant {s
k
}, et on recommence avec S

= S\{s
k
} et I

= {X S

/X {s
k
}
I}.
Retour lexemple des forts dun graphe Le thorme prcdent assure de la correction
de lalgorithme glouton d Kruskal pour construire un arbre de poids minimal : trier toutes
les artes par poids croissant, et slectionner au fur et mesure celles qui ne crent pas de cycle
si les on ajoute lensemble courant. Bien sr, il faudrait discuter dune structure de donnes
adaptes pour vrier la condition "ne cre pas de cycle" rapidement.
4.4 Ordonnancement
On donne ici un exemple dalgorithme glouton, dont on dmontre loptimalit avec la thorie
des matrodes. Cest un problme dordonnancement une machine.
Donnes : n tches T
1
....T
n
de dure 1, deadlines associes : d
1
, ..., d
n
. Pnalits associes si
le deadline est dpass : w
1
, ..., w
1
.
Ordonnancement : : T N qui chaque tche associe le top de dbut dexcution. Si une
tche T
i
nit aprs son deadline d
i
, alors cela cre la pnalit w
i
.
But : minimiser la pnalit totale, cest dire : somme sur les taches en retard des pnalits.
Intrt de lordonnancement : sur les chanes de production en usine, optimisation des calculs
sur des systmes multiprocesseurs. Ici, le problme est simpli (et cela permet que glouton
marche).
On va donc chercher le meilleur ordre pour lexcution des tches.
Dnition 3. tche lheure : tche nie avant le deadline
tche en retard : tche nie aprs le deadline.
Pour notre problme on va se restreindre :
1. Aux ordonnancements o les tches lheure prcdent les tches en retard : en eet, cela
ne restreint pas le problme, car si on avait une tche en retard qui sexcutait avant une
tche lheure, les permuter ne changerait rien la pnalit totale.
2. Aux ordonnancement o les tches lheure sont classes par ordre de deadline croissant :
de mme que prcdemment cela ne restreint pas le problme, car si on avait une tche
T
i
de deadline d
i
et une tche T
j
de deadline d
j
, avec d
i
> d
j
et T
i
sexcutant avant T
j
,
alors si on permute les ordres dexcution de T
i
et de T
j
, T
i
reste lheure, car d
i
> d
j
et
T
j
tait lheure, de plus T
j
reste lheure car on avance son moment dexcution.
On dira quon a lordre canonique si les deux conditions prcdentes sont vries.
56
Exemple : 7 tches :
T
i
1 2 3 4 5 6 7
d
i
4 2 4 3 1 4 6
w
i
7 6 5 4 3 2 1
Remarque : minimiser la pnalit totale des tches en retard maximiser la pnalit des
tches lheure.
Glouton : On commence par trier les tches par w
i
dcroissants puis on "gloutonne", cest
dire quon prend la tche si elle tient sans pnalit (on regarde si lordre canonique marche).
Application : 2,1 ;2,1,3 ;2,4,1,3 ; 2,4,1,3,7
La solution optimale est donc 2,4,1,3,7 et la pnalit minimale est 5.
Ici, lide a t de rordonner chaque fois.
Dnition 4. un ensemble de tches est indpendant elles peuvent tre excutes en tant
toutes lheure.
Lemme 4. A ensemble de tches,N
t
(A) = nombre de tches de deadline t. Les propositions
suivantes sont quivalentes :
1. A est indpendant
2. t = 1,2,...,n, N
t
(A) t
3. Ordre canonique pas de tches en retard.
Preuve. 1 2 : Par contrapose : supposons que N
t
> t, alors il y a au moins une tche
qui se droulera aprs le temps t, donc qui sera pnalise, donc A ne sera pas indpendant.
2 3 : trivial
3 1 : dnition
Proposition 1. On a un matrode.
Preuve. Hrdit : trivial
Echange : Soit A,B indpendants et |A| < |B|.Existe-t-il x appartenant B tel que A{x}
soit indpendant ?
Ide : Comparer N
t
(A) et N
t
(B) pour t=1,..,n
On cherche donc le plus grand tn tel que N
t
(A)N
t
(B). On sait que t<n donc :N
t
(A)N
t
(B)
,N
t+1
(A)<N
t+1
(B),...,N
n
(A)<N
n
(B) Dans B il y a plus de tches de deadline t+1 que dans
A Jen prends une qui nest pas dj dans A :x et alors A{x} marche.
4.5 Exercices
Exercice 4.5.1. Couverture par intervalles
Etant donn un ensemble {x
1
, . . . , x
n
} de n points sur une droite, dcrire un algorithme qui
dtermine le plus petit ensemble dintervalles ferms de longueur 1 qui contient tous les points
donns. Prouver la correction de votre algorithme et donner sa complexit.
57
Correction.
dbut
Trier dans lordre croissant les x
i
;
X {x
1
, . . . , x
n
};
I ;
tant que X ,= faire
x
k
min(X);
I I
_
[x
k
, x
k
+ 1]
_
;
X X\[x
k
, x
k
+ 1]
Retourner I ;
n
La complexit est nlog n (tri) + n (parcours de X), cest--dire O(nlog n)
Thorme : Cet algorithme est optimal.
Mthode 1 : avec des matrodes. Cette mthode ne fontionne pas. Il est impossible dexhi-
ber un matrode (on ne peut pas prouver la proprit dchange)
Mthode 2 : par rcurrence sur |X| . On ajoute un un les lements. On montre que le
premier est bien contenu dans lensemble fournit par lalgorithme.
Initialisation : Si on a quun seul point, lalgorithme renvoie un seul intervalle : cest
une solution optimale.
Soient un recouvrement optimal I
opt
=
_
[a
1
, a
1
+1], . . . , [a
p
, a
p
+1]
_
avec a
1
< < a
p
et le recouvrement donn par notre algorithme I
glou
=
_
[g
1
, g
1
+ 1], . . . , [g
m
, g
m
+ 1]
_
avec g
1
< < g
m
. Montrons que m = p.
On pose I =
_
I
opt
\
_
[a
1
, a
1
+ 1]
_
_

_
[g
1
, g
1
+ 1]
_
.
Puisque g
1
= x
1
, I est un recouvrement de X car a
1
x
1
a
1
+1 x
1
+1 = g
1
+1 donc
X[a
1
, a
1
+1] X[g
1
, g
1
+1] ; autrement-dit I
opt
\
_
[a
1
, a
1
+1]
_
est un recouvrement
de X\
_
[g
1
, g
1
+ 1]
_
.
Par hypothse de rcurrence, sur X\[g
1
, g
1
+ 1] une solution optimale est donne par
glouton :
_
[g
2
, g
2
+ 1], . . . , [g
m
, g
m
+ 1]
_
car |X|\[g
1
, g
1
+ 1] n 1
Comme I
opt
\
_
[a
1
, a
1
+ 1]
_
est un recouvrement de X\[g
1
, g
1
+ 1] avec p 1 intervalles,
on a :
p 1 m1 p m
I
opt
optimal sur X
I
glou
recouvrement de X
_
m p
_
_
_
m = p
Puisque p est le nombre dintervalles que renvoie un algorithme optimal, et que m = p,
alors, notre glouton est optimal.
Exercice 4.5.2. Codage de Human
Soit un alphabet ni de cardinal au moins deux. Un codage binaire est une application injective
de dans lensemble des suites nies de 0 et de 1 (les images des lettres de sont appeles
mots de code). Il stend de manire naturelle par concatnation en une application dnie sur
lensemble

des mots sur . Un codage est dit de longueur xe si toutes les lettres dans
sont codes par des mots binaires de mme longueur. Un codage est dit prxe si aucun mot de
code nest prxe dun autre mot de code.
1 - Le dcodage dun codage de longueur xe est unique. Montrer quil en est de mme pour un
codage prxe.
2 - Reprsenter un codage prxe par un arbre binaire dont les feuilles sont les lettres de lal-
phabet.
58
On considre un texte dans lequel chaque lettre c apparat avec une frquence f(c) non nulle.
A chaque codage prxe de ce texte, reprsent par un arbre T, est associ un cot dni par :
B(T) =

c
f(c)l
T
(c)
o l
T
(c) est la taille du mot binaire codant c. Si f(c) est exactement le nombre doccurences de
c dans le texte, alors B(T) est le nombre de bits du codage du texte.
Un codage prxe reprsent par un arbre T est optimal si, pour ce texte, il minimise la
fonction B. Montrer qu un codage prxe optimal correspond un arbre binaire o tout nud
interne a deux ls. Montrer quun tel arbre a || feuilles et || 1 nuds internes.
3 - Montrer quil existe un codage prxe optimal pour lequel les deux lettres de plus faibles
frquences sont soeurs dans larbre (autrement dit leurs codes sont de mme longueur et ne
dirent que par le dernier bit) - Proprit de choix glouton.
Etant donns x et y les deux lettres de plus faibles frquences dans , on considre lalphabet

= {x, y} + {z}, o z est une nouvelle lettre laquelle on donne la frquence f(z) =
f(x) +f(y). Soit T

larbre dun codage optimal pour

, montrer que larbre T obtenu partir


de T

en remplaant la feuille associe z par un nud interne ayant x et y comme feuilles


reprsente un codage optimal pour - Proprit de sous-structure optimale.
4 - En dduire un algorithme pour trouver un codage optimal et donner sa complexit. A
titre dexemple, trouver un codage optimal pour = {a, b, c, d, e, g} et f(a) = 45, f(b) = 13,
f(c) = 12, f(d) = 16, f(e) = 9 et f(g) = 5.
Correction.
1 - Dans un codage prxe, le dcodage est unique. En eet, si x peut se dcoder de deux faons,
alors x = ua et x = vb, et donc u est prxe de x ou v est prxe de u, donc u = v pour un
codage prxe.
2 - On peut reprsenter le codage prxe par un arbre : on associe 0 chaque branche gauche
et 1 chaque branche droite. Pour chaque caractre, on lit le code partir de la racine. Ainsi,
larbre reprsent dans la gure 4.1 correspond au codage des lettres a, b, c, d et e.
a 000
b 10
c 011
d 010
e 11
a d c
b e
0
0 0 1
1
1 0
0
Tab. 4.1 Codage de a,b,c,d et e
Chaque codage prxe optimal correspond un arbre binaire o tout nud interne a deux
ls. En eet, sil existe un nud qui na quun ls, alors on diminue le L
T
(c) en remontant le
sous-arbre correspondant : soit la feuille correspondant la lettre c tait dans le sous-arbre, dans
ce cas L

T
(c) = L
T
(c) 1, soit elle ny tait pas et L

T
(c) = L
T
(c) (cf gure 4.3).
59
Fig. 4.3 Chaque codage prxe optimal correspond un arbre binaire dont les nuds internes
ont deux ls
Un tel arbre a par construction || feuilles, puisquil code || lettres. Montrons par rcurrence
quil a || 1 nuds :
Un arbre 2 feuilles a 1 nud.
Si larbre est constitu de deux sous-arbres de i et j feuilles, alors les deux sous-arbres ont
i 1 et j 1 nuds (par hypothse de rcurrence), et larbre total a donc i 1+j 1+1 =
i +j 1 nuds, la proprit est donc vraie.
3 - Montrons quil existe un codage prxe optimal pour lequel les deux lettres de plus faibles
frquences sont surs dans larbre. Soit T un codage optimal. On a T

, B(T) B(T

). Soient x
et y les lettres de frquences les plus basses, et a et b deux lettres surs de profondeur maximale
dans T. Construisons alors un arbre T

en inversant les positions de x et de a, ainsi que celles


de y et de b.
On veut montrer que T

est optimal, cest dire que B(T) = B(T

).
B(T) B(T

) = f(a)l
T
(a) +f(b)l
T
(b) +f(x)l
T
(x) +f(y)l
T
(y)
f(a)l
T
(a) f(b)l
T
(b) f(x)l
T
(x) f(y)l
T
(y)
Comme on a les galits suivantes :
l
T
(a) = l
T
(x)
l
T
(b) = l
T
(y)
l
T
(x) = l
T
(a)
l
T
(y) = l
T
(b)
On en dduit lgalit :
B(T) B(T

) = [f(a) f(x)][l
T
(a) l
T
(x)] + [f(b) f(y)][l
T
(b) l
T
(y)]
f(a) f(x) et f(b) f(y), l
T
(a) l
T
(x) et l
T
(b) l
T
(y), donc B(T) B(T

) 0.
Donc comme T est un codage optimal, alors T

aussi. On a donc un codage prxe optimal dans


lequel les deux lettres de plus faibles frquences sont surs dans larbre. (Proprit de choix
glouton).
On considre maintenant

= \ {x, y} + {z}, o z est une nouvelle lettre de frquence


f(z) = f(x) + f(y). Soit T

larbre dun codage optimal pour

, on veut montrer que larbre


T obtenu partir de T

en remplaant la feuille associe z par un nud de feuilles x et y est


optimal pour .
60
T T`
x y
Soit T

un arbre optimal pour . Daprs la proprit de choix glouton, on peut supposer


que x et y sont surs dans T

. On peut alors construire un arbre T

en remplaant le nud de
ls x et y par une feuille z.
x y
T" T"`
On a alors B(T

) = B(T

) f(x) f(y).
Or T

est optimal, donc B(T

) B(T

). Comme B(T) = B(T

) + f(x) + f(y), on en dduit


que B(T) B(T

). Donc T est optimal car T

est optimal.
4 - On en dduit lalgorithme suivant pour le codage de Human :
Huffman(, f)
dbut
F tas_binaire(, f) ;
n || ;
pour i de 1 n 1 faire
z allouer_noeud() ;
x extraire_min(F) ;
y extraire_min(F) ;
z(gauche) x ;
z(droite) y ;
f(z) f(x) +f(y) ;
Insrer(F, z, f(z)) ;
Retourner extraire_min(F) ;
n
Calculons la complexit de cet algorithme :
Pour un tas binaire, le cot des oprations est le suivant :
Savoir si la le est vide O(1).
Insrer un lement O(log n)
Trouver un lment de cl minimale O(1)
Extraire llment de cl minimale O(log n)
La complexit dune itration de la boucle est donc en O(log n).
La complexit totale est donc en O(nlog n), car il y a n itrations de la boucle, et que la
construction du tas est en O(nlog n).
Voici larbre que lon obtient en appliquant cet algorithme = {a, b, c, d, e, g} avec f(a) =
45, f(b) = 13, f(c) = 12, f(d) = 16, f(e) = 9, f(g) = 5 :
61
a
e g
d b c
9 5
14 16
30
13 16
29
59 45
a
e g
d b c
0 1
1
1 0
0
1 0
1 0
4.6 Rfrences bibliographiques
Tout le chapitre (cours et exercice Codage de Human) sinspire du Cormen [2], lexception
des algorithmes de coloriage de graphes, tirs du West [11].
62
Chapitre 5
Tri
5.1 Tri rapide
Tri rapide : n lments trier, on prend lun dentre eux, appel pivot, et on partage les
lments en les positionnant par rapport au pivot : gauche ceux qui sont plus petits que le
pivot, et droite ceux qui sont suprieurs ou gaux. On fait deux appels rcursifs de la mthode
pour continuer, un dans chaque sous-ensemble gauche et droite.
5.1.1 Cot
Le partage se fait en temps linaire. Si on partage un tableau de taille n en deux sous-
ensembles de taille p et q, avec p + q = n, le cot TR(n) de TriRapide est TR(n) = c.n +
TR(p) +TR(q).
Daprs lanalyse faite pour diviser-pour-rgner, on obtiendra un cot TR(n) en nlog n si on
sait garantir que p et q ne sont pas trop grands. Lidal serait davoir p = q ou |p q| = 1, donc
p et q proches de
n
2
|.
Cest ce qui se passe en moyenne, et on peut montrer que la version de TriRapide, qui prend
comme pivot le premier lment du tableau courant, a un cot moyenn sur les n! permutations
en nlog n. Ce nest pas le pire cas de cette version, clairement en n
2
.
Pour avoir un pire cas en nlog n, on met en oeuvre la version o on choisit llment mdian
du tableau courant, autour duquel on va partager les lments. Comme il existe un algorithme
linaire pour le calcul de la mdiane, expos ci-dessous, le but est atteint.
Il faut noter que TriRapide fonctionne trs rapidement en pratique, et cest lui qui sous-tend
la routine qsort() dUnix.
5.1.2 Mdiane en temps linaire
Problme
donnes : ensemble A de n lments distincts totalement ordonn
rsultat : le i-me lment x de A.
remarque : on pourrait trier A et sortir le i-me lment, ce qui se fait en O(nlog n).
dnition : intuitivement, y est mdiane de A ssi A possde autant dlments suprieurs
y que dlments infrieurs y. On dit que la mdiane de A est llment de rang
n+1
2
|
pour rgler le cas o n est pair.
63
Algorithme
faire des paquets de taille 5 (sauf le dernier ventuellement de taille infrieure) ;
prendre la mdiane de chaque paquet ;
prendre la mdiane Z des mdianes ;
partitionner autour de Z : . . .
..
k1
Z . . .
..
nk
;
si k = i, renvoyer Z ;
si k > i, appel rcursif : chercher le i-me parmi les k 1 lments de gauche ;
si k < i, appel rcursif : chercher le (i k)-me parmi les n k lments de droite.
Complexit Soit n quelconque et n

le premier multiple de 5 impair suprieur ou gal n.


Alors n n

n + 9.
Si n

= 5(2m+ 1), la liste des mdianes est la suivante :


Z
1
. . . Z
m
Z Z
m+2
. . . Z
2m+1
On voit quil y a
_
au moins 3m+ 2 lments infrieurs Z
au moins 3m+ 2 lments suprieurs Z
Le cot de lalgorithme ci-dessus T(n) vrie
T(n) = T(
n

5
) +T(n

3m2) +an
Remarque :
_
n

n + 9
n

3m2 n

3
2
(
n

5
1) 2
7
10
(n + 9)
1
2

7
10
n + 6
Thorme 8. c, T(n) cn
Preuve. Par rcurrence, supposons le rsultat vrai k < n. Alors
T(n) c
n + 9
5
+c(
7
10
n + 6) +an = (
9
10
c +a)n +
39
5
c
On veut (
9
10
c +a)n +
39
5
c cn .
Or
39c
5

cn
20
ssi 20
5n
39
ssi n 156 .
Donc pour n 156, (
9c
10
+a)n +
39c
5
(
19c
20
+a)n.
Ainsi il sut de prendre
_
c 20a
c max
1k156
T(k)
k
5.2 Tri fusion
Tri Fusion : n lments trier, appel de TF(1,n) appels rcursifs de TF(1,n/2|) et
TF(n/2| + 1,n) puis fusion des deux sous listes tries.
Algorithme de fusion de deux listes de taille p et q : on compare les deux premiers des deux
listes, on prend le plus petit et on recommence avec les deux listes restantes. On fait un total
de p +q 1 comparaisons.
64
Complexit : ici, cest en terme de comparaisons quil faut compter. Comme la somme des
tailles des deux listes fusionner est toujours n/2| +n/2| = n :
comp
TF
(n) = comp
TF
(n/2|) +comp
TF
(n/2|) +n 1
avec comp
TF
(1) = 0
Donc, daprs le Master Thorme, comp
TF
(n) = _(nlog
2
n). En fait, on peut montrer par
rcurrence un peu technique (distinguer les cas o n = 2
r
et n = 2
r
1), que
comp
TF
(n) = nlog
2
n| 2
log
2
n
+ 1
Avantages : Pas de grosse constante devant (nlog
2
n), complexit constante (en moyenne,
au pire, etc.)
Inconvnients : Prend beaucoup de place, dicult de fusionner deux listes "sur place",
besoin dun tableau auxiliaire de taille n, on lutilise donc peu en pratique.
5.3 Tri par tas : Heapsort
5.3.1 Dnitions
Arbre binaire parfait : tous les niveaux de larbre sont complets sauf le dernier que lon
remplit de gauche droite.
Arbre partiellement ordonn : la valeur dun ls est suprieure ou gale la valeur du
pre.
Tas : arbre binaire et partiellement ordonn.
Soit un tas de n lments numrots de 1 n. Considrons un noeud i de larbre qui ne soit
pas la racine. Son pre est
i
2
|. Son ls gauche est 2i sil existe (2i n) et son ls droit est
2i + 1 sil existe (2i + 1 n). Pour tout noeud i autre que la racine : A[pre(i)] A[i].
Fig. 5.1 Exemple de tas
Lavantage du tas est lutilisation dun tableau de taille n comme structure de donnes : on
na pas besoin de pointeurs ls gauche ls droit.
5.3.2 Tri par tas
Soit n lments que lon souhaite trier. On les insre un un dans le tas (procdure inser-
tion), on extrait le minimum puis on rorganise le tas.
65
proc trier_par_tas
FOR i=1 TO n
inserer(TAS,ime lment)
FOR i=1 TO n
suppression_min(TAS)
5.3.3 Insertion dun nouvel lment
Il faut garder le caractre partiellement ordonn de larbre et, plus dur, son caractre parfait.
On place si possible llment droite de la dernire feuille, et si le niveau est complet on le
place en dessous, tout gauche. On procde ensuite par changes locaux : on compare llment
avec son pre, et on les change si lingalit nest pas respecte. Le cot de linsertion est log(n)
puisque lon fait au plus autant de comparaisons quil y a dtages dans larbre.
PROC inserer(var TAS::array[1..n],n,x)
n=n+1
TAS[n]=x
fini=FALSE
pas=n
WHILE (NOT(fini)) DO
IF pas=1 THEN fini=TRUE
ELSE IF TAS[(pas)div(2)] \le TAS[pas]
THEN fini=TRUE
ELSE TAS[pas]=TAS[(pas)div(2)]
pas=(pas)div(2)
5.3.4 Suppression dun lment du tas
On supprime la racine et on rorganise le graphe. Pour faire ceci, on fait remonter le dernier
lment (en dessous tout droite) en le substituant la racine. On compare llment ses deux
ls, et si au moins lun des deux est suprieur llment, on change le plus grand des deux ls
llment.
proc suppression_min(var TAS::array[1..n])
x=TAS[1]
TAS[1]=TAS[n]
n=n-1
i=1
WHILE NOT(fini) DO
IF i > n div 2 (i est une feuille)
THEN fini = TRUE
ELSE
IF 2i=n or TAS[2i] < TAS[2i+1]
THEN j=2i ELSE j=2i+1
IF TAS[i] > TAS[j]
THEN echange(TAS[i],TAS[j]); i=j
ELSE fini = TRUE
66
5.4 Complexit du tri
5.4.1 Les grands thormes
Attention. On travaille dans un univers o on ne fait que des comparaisons. On a un ordre
total pour les lments quon veut trier, mais pas dautre opration, ni dinformation sur lunivers
des lments. Sans ces hypothses, il existe des tris dirents, sans comparaison du tout
proprement parler. Par exemple RadixSort utilise la dcomposition binaire des entiers quil trie
(penser un jeu de cartes quon trie par couleur avant de trier par valeur). Par exemple encore,
si on a linformation que tous les lments sont des entiers entre 1 et K, on prpare un tableau
de taille K et on stocke en case i le nombre dlments gaux i ; remplir ce tableau nexige
quun seul parcours des n lments, quon va pouvoir trier en temps linaire.
Thorme 9. Il faut log
2
(n!)| = O(nlog(n)) comparaisons au pire pour trier n lments.
Thorme 10. Il faut log
2
(n!)| = O(nlog(n)) comparaisons en moyenne pour trier n lments.
Rappel sur la complexit en moyenne : n! donnes direntes possibles (toutes les permuta-
tions des n lments). Pour chaque donne on compte le nombre de comparaisons ncessaires.
On fait la moyenne de tous les cas possibles (la complexit moyenne est rarement calculable).
Bien sr le second thorme implique le premier, mais on va le dmontrer sparment. En
fait, on va dmontrer que log(n!)| est une borne infrieure pour la complexit au pire et en
moyenne. On a vu que la complexit de tri fusion ne dpend pas des donnes et vaut comp
TF
(n) =
nlog
2
(n)|2
log
2
(n)
+1, ce qui tend vers nlog
2
(n), montrant ainsi que la borne peut tre atteinte
asymptotiquement.
5.4.2 Dmonstration des thormes
Voici le droulement dun tri en deux boucles (tri bulle), dont le code pour trier un tableau
t[1..n] est le suivant :
for i = 1 to n do
for j = n downto i+1 do
if t[j] < t[j-1] then t[j] <-> t[j-1]
On a reprsent larbre de dcision : cest la trace de lexcution pour toutes les donnes
possibles. Cest un arbre binaire (chaque comparaison renvoie oui ou non). Il ny a pas toujours
deux ls (larbre nest pas localement complet), mais il y a exactement n! feuilles.
Lemme 5. Il y a exactement n! feuilles dans tout arbre de dcision dun algorithme qui trie n
lments.
67
Preuve. On fait des comparaisons entre les lments. Si larbre avait moins de n! feuilles, une
mme feuille correspondrait deux permutations direntes, ce qui nest pas possible. Pour une
permutation donne, il y a toujours le mme chemin dexcution, donc la mme feuille, et le
nombre de feuille est au plus n!.
Il faut distinguer Hauteur maximale et Hauteur moyenne. La complexit de lalgorithme
pour une donne correspond la hauteur de la feuille associe.
Pour dmontrer les thormes, on a maintenant un problme dhauteur darbre binaire. La
hauteur dune feuille est sa distance la racine (dnition), cest le nombre de comparaisons
eectues pour la donne correspondante.
On va montrer que pour un arbre n! feuilles, sa hauteur maximale, puis sa hauteur moyenne,
sont suprieures log
2
(n!)|. On termine avec la formule de Stirling pour estimer log
2
(n!) =
O(nlog(n)) :
Lemme 6. Pour tout arbre f feuilles, la hauteur moyenne est suprieure log
2
(f)|.
Pour la hauteur maximale, cest facile. On considre larbre avec le plus de feuilles et le moins
haut : larbre complet. On a donc la preuve du premier thorme.
Preuve. Pour la hauteur moyenne, on procde par rcurrence sur le nombre de feuilles :
f = 1 : a marche (vident), h = 0
cas gnral : supposons la proprit vraie pour tout f

< f, et considrons un arbre f


feuilles. Il y a trois cas :
cas 1 cas 2 cas 3
cas 1 et 2 : profondeur des feuilles (distance r) = 1 + distance la sous-racine r. On itre
la construction jusqu tomber sur le cas 3, celui dune racine qui a deux sous-arbres.
cas 3 : (plus compliqu), on considre f = f
1
+ f
2
, avec f
1
,= 0 et f
2
,= 0. On peut alors
utiliser lhypothse de rcurrence.
La profondeur moyenne dune feuille est :
- si f est gauche, on a Prof
T
(f) = 1 +Prof
T
1
(f)
- si f est droite, on a Prof
T
(f) = 1 +Prof
T
2
(f).
On va alors pouvoir calculer la profondeur moyenne de T :
Prof
moy
(T) =

T
Prof
T
(f)
f
Prof
moy
(T) =

T1
Prof
T
(f) +

T2
Prof
T
(f)
f
Prof
moy
(T) =
f
1
+

T1
Prof
T
(f)
f
+
f
2
+

T2
Prof
T
(f)
f
Prof
moy
(T) =
f
1
+Prof
moy
(T1) f1
f
+
f
2
+Prof
moy
(T2) f2
f
68
Prof
moy
(T) = 1 +
Prof
moy
(T1) f1
f
+
Prof
moy
(T2) f2
f
Prof
moy
(T) 1 +
f1 log
2
(f1)| +f2 log
2
(f2)|
f
1
+f
2
Il y a 2 manires de dmontrer la dernire ingalit :
en crivant f
2
= f f
1
, on considre la fonction f
1
Prof
moy
(T), dont on obtient le
minimum en la drivant.
on observe que cette fonction est concave, et le minimum obtenu pour f
1
= f
2
, donc
suprieur 1 +log
2
(f)| 1
Autre preuve : preuve de Shannon. Il y a n! donnes, donc log
2
(n!)| bits dinformations
acqurir. Comme une comparaison permet dacqurir 1 bit, il en faut au moins log
2
(n!)| pour
trier les donnes.
5.4.3 Peut-on atteindre la borne ?
On sait quil faut au moins log
2
(n!)| comparaisons, mais cette borne est-elle atteignable ?
Asymptotiquement oui, car nous avons trois algorithmes dont la complexit dans le pire des cas
tat en nlog(n). Regardons si cest le cas si on regarde la comparaison prs. Dans le tableau ;
on note le nombre de comparaisons eectu par TriFusion, la valeur de la borne, et le nombre
de comparaisons dune solution optimale dcrite plus bas :
n 2 3 4 5 6 7 8 9 10 11 12
TriFusion(n) 1 3 5 8 11 14 17 21 25 29 33
log
2
(n!)| 1 3 5 7 10 13 16 19 22 26 29
Opt(n) 1 3 5 7 10 13 16 19 22 26 30
Une ide importante est linsertion par dichotomie. Insrer un lment dans une suite trie
de k lments cote r comparaisons au pire si k 2
r
1. Il est donc plus avantageux dinsrer
dans une chane de taille 3 que de taille 2, et dans une chane de taille 7 que de taille 4 6, car
le cot au pire est le mme.
trier 3 nombres :
on en prend 2 au hasard et on compare le 3me aux deux autres, cot 3.
trier 4 nombres :
tri incrmental : on trie les 3 premiers (a > b > c), puis on insre le 4me par
dichotomie, cot 3+2=5
diviser pour rgner :
on forme 2 paires de 2, (a > b) et (d > c), on compare les deux plus grands pour
obtenir par exemple (a > b > c), on insre d par dichotomie, cot 2+1+2=5
trier 5 nombres :
faire deux paires sur a, b, c, d et comparer les plus grands (cot = 3) pour obtenir le mme
dessin que plus haut, puis on insre e dans la chane (a, b, c) (cot = 2), et on insre d
dans (e, a, b) (si e < a), (a, e, b) (si e entre a et b), (a, b, e) (si e entre b et c), ou (a, b) (si
e > c), avec un cot 2 dans tous les cas. Il y a donc 7 comparaisons faire.
69
trier 6 nombres :
6 = 5 + 1 : on insre le 6me dans les 5 premiers (cot = 7 + 3 = 10)
trier 7 nombres :
7 = 6 + 1 : on insre le 7me dans les 6 premiers (cot = 10 + 3 = 13)
trier 8 nombres :
8 = 7 + 1 : on insre le 8me dans les 7 premiers (cot = 13 + 3 = 16)
trier 9 nombres (a, b, c, d, e, x, y, z, t) :
On forme 4 paires : (a, b), (x, c), (y, d), (z, e), t est isol. Cot : 4 pour former les paires.
On trie (b, c, d, e), cot 5 = Opt(4). Puis on insre dans lordre y, x, t, z. Cots respectifs :
2,2,3,3. Cot total : 19.
trier 10 nombres : (a, b, c, d, e, f, x, y, z, t) :
On forme 5 paires (a, b), (x, c), (y, d), (z, e), (t, f) (cot 5), on trie (b, c, d, e, f) (cot 7 =
Opt(5)) puis on insre y dans (a, b, c) (cot 2), x dans (a, b, y?) (cot 2) puis t dans une
chane de longueur 7 (cot 3) et z dans une chane de longueur 6 ou 7 (cot 3). Cot total
22.
trier 11 nombres :
11 = 10 + 1, on utilise la mthode incrmentale.
trier 12 nombres :
Il faut au minimum 30 comparaisons (mthode 12 = 11 + 1), cest impossible de le faire
en 29 comparaisons, on a tous test tous les algorithmes possibles par ordinateur (brute
force).
5.5 Exercices
Exercice 5.5.1. Hors duvre
On considre un ensemble S de n 2 entiers distincts stocks dans un tableau (S nest pas
suppos tri). Rsoudre les questions suivantes :
1 - Proposer un algorithme en O(n) pour trouver deux lments x et y de S tels que |x y|
|u v| pour tout u, v S.
2 - Proposer un algorithme en O(nlog n) pour trouver deux lments x et y de S tels que x ,= y
et |x y| |u v| pour tout u, v S, u ,= v.
3 - Soit m un entier arbitraire (pas ncessairement dans S), proposer un algorithme en O(nlog n)
pour dterminer sil existe deux lments x et y de S tels que x +y = m.
70
4 - Proposer un algorithme en O(n) pour trouver deux lments x et y de S tels que |x y|
1
n1
(max(S) min(S)).
Correction.
1 - Pour que |a b| soit maximum il faut que a (Resp b) soit maximum et que b (Resp a) soit
minimum. Le problme se rsume donc une recherche du min et du max qui se fait en O(n).
2 - Si |c d|, est minimum pour c et d appartenant S alors il nexiste pas e appartenant S
tel que a > e > b ou a < e < b : sinon |c e| < |c d|. On trie donc S en O(n logn) et on
cherche ensuite le min des s
i
s
i+1
, (s
i
et s
i+1
tant deux entier conscutifs de S) en O(n).On
obtient donc un algorithme en O(n logn).
3 - On commence par trier S en O(n logn).Ensuite pour tout y appartenant S on cherche
si m y appartient S par dichotomie (S est tri), la dichotomie se faisant en O(logn) cette
opration ce fait en O(n logn). A la n on obtient bien un algorithme en O(n logn).
4 - Il existe deux mthodes pour rsoudre cette question.
4.1 - Premire mthode
Cette mthode est base sur la mdiane. On note S
1
lensemble des lment de S infreurs la
mdiane et S
2
les lments de S suprieurs la mdiane. Il est noter que |S
1
| = |S
2
| =
S
2
|.
dbut
Calculer le min et le max de S ;
si n = 2 alors retourner (Min,Max) ;
sinon
extraire la mdiane de S ; calculer S
1
S
2
;
relancer lalgo sur S
1
ou S
2
suivant le cas.
n
Preuve de lalgorithme : on pose M(S) la moyenne pondre de S, n =| S |, a le min de S,
b le max de S, et m la mdianne de S, deux cas sont alors possibles :
n impair :
n = 2k + 1, alors|S
1
| =
n + 1
2
= k + 1
donc :M(S
1
) =
ma
k + 1 1
=
ma
k
et :|S
2
| =
n + 1
2
= k + 1
donc :M(S
2
) =
b m
k + 1 1
=
b m
k
donc :
M(S
1
) +M(S
2
)
2
= (
ma
k
+
b m
k
)
1
2
=
b a
2k
or :
b a
2k
=
b a
n 1
= M(S)
donc :2 M(S) = M(S
1
) +M(S
2
)
nalement :M(S
1
) M(S)ouM(S
2
) M(S).
71
n pair :
n = 2k, alors|S
1
| =
n + 1
2
= k
donc :M(S
1
) =
ma
k 1
et :|S
2
| =
n + 1
2
donc :M(S
2
) =
b m
k 1
donc :
M(S
1
) +M(S
2
)
2
= (
ma
k 1
+
b m
k 1
)
1
2
=
b a
2k 2
or :
b a
2k 2

b a
n 1
= M(S)
donc :2 M(S) M(S
1
) +M(S
2
)
nalement :M(S
1
) M(S)ouM(S
2
) M(S).
Comme on sait que M(S
1
) M(S) ou M(S
2
) M(S) cela nous permet denclencher
linduction : soit sur S
1
, soit sur S
2
. Rechercher la moyenne se fait en O(n), chercher le min et
le max dun ensemble aussi, donc :
C(n) = C(
n
2
|) +O(n)
Ce qui donne par master thorme
C(n) = O(n)
4.2 - Deuxime mthode
On divise S en (n 1) boites.
dbut
si il ny a quune boite alors on renvoie deux de ses lments;
sinon
si le nombre dlments des
n1
2
| premires boites est suprieur
n1
2
|. alors la
moyenne pondre sur les
n1
2
| premires boites est infrieure celle de S, et on
relance lalgorithme sur ces boites. ;
sinon
le nombre dlments des
n+1
2
| dernires boites est suprieur
n+1
2
|, et alors
la moyenne pondre sur les
n+1
2
| dernires boites est infrieure celle de S,
et on relance lalgorithme sur celles-ci.
n
Quant la complexit elle est en O(n) :
C(n) = C(
n
2
| + 1) +O(n)
Ce qui donne par master thorme
C(n) = O(n)
72
Dans les exercices suivants, on sintresse des ensembles de n entiers tous distincts rangs
dans un tableau T[1], . . . , T[n]. Les algorithmes considrs ici eectuent des aectations et
leur seul critre de dcision (ou de bifurcation) est la comparaison de deux lments (= et
<). En aucun cas ils ne peuvent eectuer des oprations arithmtiques, comme laddition ou la
multiplication.
Exercice 5.5.2. Maximum de n entiers
1 - Ecrire un algorithme (naf !) qui calcule le maximum de n entiers. Quelle en est la complexit
(en nombre de comparaisons eectus, en nombre daectations eectues, dans le pire des cas,
le meilleur, en moyenne) ?
Indications pour le calcul des aectations en moyenne : soit P
n,k
le nombre de permutations
de {1, . . . , n} telles que sur la donne T[1] = (1),...,T[n] = (n) lalgorithme eectue k
aectations. Donner une relation de rcurrence pour P
n,k
. Soit G
n
(z) =

P
n,k
z
k
. Montrer que
G
n
(z) = z(z + 1) (z +n 1). En dduire le rsultat.
2 - Lalgorithme que vous avez propos est-il optimal pour la complexit en comparaisons dans
le pire des cas ?
Correction.
1- On donne ici un algorithme naf pour le calcul du maximum de n entiers :
dbut
max T[1]
pour i de 1 n faire
si T[i] > max alors max T[i]
n
Retourner max
n
Complexit en nombre de comparaisons : quel que soit le cas, on eectue n 1 comparaisons
dans lalgorithme, chaque lment aprs le premier tant compar une fois.
dans le pire des cas : n (si le tableau est ordonn de manire croissante),
dans le meilleur des cas : 1 (si le maximum est en premire position),
en moyenne : pour le calcul de la complexit en moyenne, il va falloir faire appel un
calcul plus pouss :
Rappel : complexit en moyenne dun algorithme A de donnes de taille n :
moy
A
(n) =

n donnes de taille m
p(d)cot
A
(d)
o p(d) est la probabilit que d soit une entre de lalgorithme A.
les donnes sont les permutations de [1, . . . ,n] stockes dans T. Les permutations tant
totalement alatoires et ntant rgies par aucune loi mathmatique, on peut les supposer
quiprobables.
le cot dun algorithme A(T) est son nombre daectation. Ainsi, pour chaque cas de
P
n,k
, lalgorthime eectue k aectations. On obtient donc ainsi que le cot dun algo-
rithme A(T) est de kP
n,k
.
do :
moy
A
(n) =
1
n!

T permutations de [1,...,n]
cout
A
(T) =
1
n!
n

k=1
kP
n,k
trouvons P
n,k
:
73
supposons le max en T[n] : pour avoir k aectations en tout, il faut : P
n1,k1
sinon, les aectations sont ralises avant et on a alors n 1 permutations possibles :
P
n1,k
Donc P
n,k
= P
n1,k1
+ (n 1)P
n1,k1
cas limites :
P
n,0
= 0
si k > n : P
n,k
= 0
n N : P
n,n
= 1
Utilisons les sries gnratrices : G
n
(z) =

n
k=1
P
n,k
z
k
G
n+1
(z) =
n+1

k=1
P
n,k
z
k
=
n+1

k=1
(P
n,k1
+nP
n,k
)z
k
=
n+1

k=1
P
n,k1
z
k1
+n
n+1

k=1
P
n,k
z
k
=
n

k=0
P
n,k
z
k
+n
n+1

k=1
P
n,k
z
k
Or P
n,0
= 0 et P
n,n+1
= 0 do :
G
n+1
(z) = z
n

k=0
P_n, kz
k
+n
n

k=1
P
n,k
z
k
do :
G
n+1
(z) = (z +n)G
n
(z)
Or G
1
(z) = P
1,1
z = z do G
n
(z) = z(z + 1) . . . (z +n 1)
de plus :
G

n
(z) =
n

k=1
kP
n,k
z
k1
do : G

n
(1) =
n

k=1
kP
n,k
de mme : G
n
(1) =
n

k=1
P
n,k
= n!
74
On obtient donc :
moy
A
(n) =
G

n
(1)
G
n
(1)
= [lnG(z)]

(1)
= [
n1

i=0
ln(z +i)]

(1)
= 1 +
1
2
+ +
1
n
= H
n
(la suite harmonique lordre n)
moy
A
(n) = O(ln n)
2- Optimalit en terme de comparaisons
Une comparaison est un match entre deux entiers, le gagnant tant le plus grand. Si le max
est connu, cest que tout les autres entiers ont perdu au moins une fois un match contre lui,
ce qui demande en tout n 1 comparaisons. Notre algorithme en faisant toujours n 1, il est
optimal pour la complexit en nombre de comparaisons.
Exercice 5.5.3. Plus petit et plus grand
Dans lexercice suivant, on ne sintresse plus qu la complexit dans le pire des cas et en
nombre de comparaisons des algorithmes.
1- On sintresse maintenant au calcul (simultan) du maximum et du minimum de n entiers.
Donner un algorithme naf et sa complexit.
2 - Une ide pour amliorer lalgorithme est de regrouper par paires les lments comparer,
de manire diminuer ensuite le nombre de comparaisons eectuer. Dcrire un algorithme
fonctionnant selon ce principe et analyser sa complexit.
3 - Montrons loptimalit dun tel algorithme en fournissant une borne infrieure sur le nombre
de comparaisons eectuer. Nous utiliserons la mthode de ladversaire.
Soit A un algorithme qui trouve le maximum et le minimum. Pour une donne xe, au
cours du droulement de lalgorithme, on appelle novice (N) un lment qui na jamais subi de
comparaisons, gagnant (G) un lment qui a t compar au moins une fois et a toujours t
suprieur aux lments auxquels il a t compar, perdant (P) un lment qui a t compar au
moins une fois et a toujours t infrieur aux lments auxquels il a t compar, et moyens (M)
les autres. Le nombre de ces lments est reprsent par un quadruplet dentiers (i, j, k, l) qui
vrient bien sr i +j +k +l = n.
Donner la valeur de ce quadruplet au dbut et la n de lalgorithme. Exhiber une stratgie
pour ladversaire, de sorte maximiser la dure de lexcution de lalgorithme. En dduire une
borne infrieure sur le nombre de tests eectuer.
Correction.
1 - On donne ici un algorithme naf pour le calcul du maximum et du minimum de n entiers :
75
dbut
max T[1]
i
max
1
min T[1]
pour i de 2 n faire
si T[i] > max alors max T[i] ; i
max
i
n
pour i de 2 n faire
si i ,= i
max
et min < T[i] alors min T[i]
n
Retourner (max,min)
n
Complexit en nombre de comparaisons : On eectue n 1 comparaisons pour trouver le maxi-
mum, et n 2 pour trouver le minimum. On a donc une complexit en 2n 3.
2 - Groupement des lments par paires
On regroupe maintenant les lments par paire pour ensuite eectuer les oprations de com-
paraisons.
Lalgorithme suivant permet de rsoudre le problme pos :
dbut
pour i de 1
n
2
| faire
si T[2i 1] > T[2i] alors change T[2i 1] et T[2i]
n
max T[2]
pour i de 2
n
2
| faire
si T[2i] > max alors max T[2i]
n
min T[1]
pour i de 2
n
2
| faire
si T[2i 1] < min alors min T[2i 1]
n
si n impair alors si T[n] > max alors max T[n]
sinon si T[n] < min alors min T[n]
n
Complexit associe :
si n est pair, on va avoir
n
2
comparaisons pour faire les paires,
n
2
1 comparaisons pour
trouver le maximum et autant pour le mimimum. Dans ce cas l, la complexit vaut donc :
3n
2
2
si n est impair, le nombre de comparaisons est infrieur ou gal 3
n
2
|, donc infrieur ou
gal
3n
2
| 2.
3- Mthode de ladversaire
Cette mthode va tre utilise pour fournir une borne infrieure sur le nombre de comparai-
sons eectuer et ainsi montrer loptimalit de lalgorithme prcdent.
Dnitions :
- Novice : lment qui na jamais t compar
- Gagnant : lment qui a gagn tout ses matchs
76
- Perdant : lment qui a perdu tout ses matchs
- Moyen : lment qui a gagn et perdu
Soit A notre algorithme. On note (i, j, k, l) respectivement le nombre de novices, gagnants,
perdants et moyens (avec i +j +k +l = n).
Au dbut de lalgorithme, on a (i, j, k, l) = (n, 0, 0, 0). A la n, (i, j, k, l) = (0, 1, 1, n 1).
Le but de ladversaire est de maximiser la dure de lalgorithme tout en conservant une stra-
tgie cohrente. On peut alors donner lensemble des oprations rsumes dans le tableau 5.5.3
comparaison choix i j k l
N :N i 2 j + 1 k + 1 /
N :G G > N n 1 / k + 1 /
N :P P < N n 1 j + 1 / /
N :M M > N i 1 / k + 1 /
N > M
1
i 1 j + 1 / /
G :G / j + 1 / l + 1
G :P G > P / / / /
G :M G > M / / / /
P :P / / k 1 l + 1
P :M P < M / / / /
M :M / / / /
/ reprsente les cas o lentier reste inchang.
Cherchons donner une borne infrieure sur le nombre de tests eectuer.
Il faut que chaque novice soit compar au moins une fois. La comparaison la plus ecace est alors
N :N car elle diminue le nombre de novice de deux, et il en faut au moins
n
2
| pour atteindre
le bon nombre de novices.
De plus, il faut la n que lon ait n 2 moyens, ce qui ncessite au moins n 2 autres
comparaisons.
Do au minimum
n 2 +
_
n
2
_
=
_
3n
2
_
2 comparaisons.
La borne infrieure sur le nombre de tests eectuer est gale la complexit de lalgorithme
prcdent. On montre ainsi que ce dernier est optimal.
Exercice 5.5.4. Plus grand et deuxime plus grand de n entiers
On sintresse dans cet exercice la complexit dans le pire des cas et en nombre de
comparaisons des algorithmes.
1 - Pour rechercher le plus grand et deuxime plus grand lment de n entiers, donner un
algorithme naf et sa complexit.
2 - Pour amliorer les performances, on se propose denvisager la solution consistant calculer le
maximum suivant le principe dun tournoi (tournoi de tennis par exemple). Plaons-nous dabord
dans le cas o il y a n = 2
k
nombres qui sarontent dans le tournoi. Comment retrouve-t-on,
une fois le tournoi termin, le deuxime plus grand ? Quelle est la complexit de lalgorithme ?
Dans le cas gnral, comment adapter la mthode pour traiter n quelconque ?
3 - Montrons loptimalit de cet algorithme en fournissant une borne infrieure sur le nombre de
comparaisons eectuer. Nous utiliserons la mthode des arbres de dcision.
77
3.1 - Montrer que tout arbre de dcision qui calcule le maximum de N entiers a au moins
2
N1
feuilles.
3.2 - Montrer que tout arbre binaire de hauteur h et avec f feuilles vrie 2
h
f.
3.3 - Soit A un arbre de dcision rsolvant le problme du plus grand et deuxime plus grand
de n entiers, minorer son nombre de feuilles. En dduire une borne infrieure sur le nombre
de comparaisons eectuer.
Correction.
1 - Algorithme naf : recherche du premier maximum, puis du second.
dbut
max
1
T[1];
pour i allant de 2 n faire
si T[i] > max
1
alors
max
1
T[i];
posmax
1
i;
si posmax
1
,= 1 alors max
2
T[1] sinon max
2
T[2];
pour i allant de 2 n avec i ,= posmax
1
faire
si T[i] > max
2
alors
max
2
T[i];
retourner max
1
, max
2
;
n
Nombre de comparaisons :
Premier maximum, sur n valeurs : n 1
Second maximum, sur n - 1 valeurs : n 2
2n 3
2 - Cas o n = 2
k
:
On calcule le premier maximum la faon dun tournoi de tennis. On cherche ensuite le second
maximum, en prenant le maximum parmi les adversaires que le premier rencontr. Ainsi, dans
larbre donn la gure 5.2, le second maximum est ncessairement un lment contenu dans le
chemin rouge.
Fig. 5.2 Arbre des comptitions eectues
78
Nombre de comparaisons :
Premier maximum : n 1 = 2
k
1
Second maximum : k 1
2
k
+k 2 = n +log
2
n 2
Cas gnral : n quelconque
Sil nest pas rempli et a une profondeur minimale, la branche de longueur maximale est de
longueur log
2
n|.
Au pire, nombre de comparaisons :
Premier maximum : n 1
Second maximum : log
2
n| 1
n +log
2
n| 2
3.1 - Pour chercher le maximum parmis N valeurs, on doit eectuer N 1 comparaisons.
On a donc 2
N1
feuilles dans larbre de dcision.
3.2 - Par rcurrence sur la hauteur h de larbre
Pour h = 0 : 1 feuille au plus
On considre un arbre de hauteur h + 1 , on a alors deux cas, soit la racine a un seul ls
soit il en a deux.
un ls : on alors le nombre de feuille qui correspond celui de larbre partant du ls,
qui est de hauteur h , et 2
(
h + 1) 2
h
ce qui va bien.
deux ls : on a alors le nombre de feuilles qui correspond la somme de celles des deux
sous arbresz partants des deux ls : f = f
1
+ f
2
, en ayant pour chacun une hauteur
maximale de h soit : 2
(
h + 1) 2
h
+ 2
h
2
h
1
+ 2
h
2
f
1
+f
2
f cqfd.
3.3 - On partitionne les feuilles de A selon la valeur du premier maximum pour former les A
i
; A
i
est au nal larbre A dont on a enlev tous ce qui naboutissait pas une feuille concluant que
le premier maximum tait i. Ces A
i
sont des arbres donnant un maximum parmi n-1 lments
donc ils ont chacun un nombre de feuilles tel que : nombre de feuilles de A
i
2
n2
Donc en
considrant A comme la fusion de ces arbres qui en forme une partition, on a :
nombredefeuillesdeA
n

i=1
2
n2
n2
n2
2
hauteur
n2
n2
hauteur log
2
(n2
n2
)|
n 2 +log
2
n|
Exercice 5.5.5. Du ptrole et des ides
Le professeur Robert Ive est consultant pour une compagnie ptrolire qui projette de construire
un grand oloduc en ligne droite dEst en Ouest travers un champ ptrolier. partir de
chaque puits un raccordement doit tre connect directement sur loloduc principal suivant le
plus court chemin. Connaissant les coordonnes des puits, comment le professeur trouvera-til
lemplacement idal de loloduc principal qui minimise la longueur totale des raccordements ?
79
Correction.
Ide simplicatrice : projeter tous les puits sur laxe Nord-Sud.
Avec deux points seulement, la longueur totale des raccordements est minimale si loloduc
passe entre les puits, ou mme sur lun des puits :
P1
P2
Soit y
k
lordonne de P
k
. Laltitude optimale de loloduc est le mdian est y
k
. La chose est
suppose assez vidente pour se dispenser de la prouver.
Si le nombre n de puits est pair, on a le choix entre deux mdians : infrieur ou suprieur.
Si n est impair, loloduc passe par le puit mdian.
Exercice 5.5.6. Mdian pondr
Soient n lments distincts x
1
, ..., x
n
de poids positifs p
1
, ..., p
n
tels que
n

i=1
p
i
= 1
Le mdian pondr (infrieur) est llment x
k
satisfaisant :

x
i
<x
k
p
i
<
1
2
et

x
i
>x
k
p
i

1
2
1 - Dmontrer que le mdian de x
1
, ..., x
n
est le mdian pondr des x
i
aects des poids p
i
= 1/n
pour i compris entre 1 et n.
2 - Comment calculer simplement le mdian pondr de n lments. Donner la complexit en
comparaisons et en additions.
3 - Comment calculer le mdian pondr en temps linaire dans le pire des cas.
80
Correction.
1 - On cherche calculer le mdian des x
k
.

x
i
<x
k
p
i
<
1
2
et

x
i
>x
k
p
i

1
2
=
k1
n
<
1
2
et
nk
n

1
2
= k 1 <
n
2
et n k
n
2
=
n
2
k <
n
2
+ 1
= k =
_
n
2
_
cest le mdian infrieur.
2 - Algorithme simple de calcul du mdian pondr
dbut
Trier les lments : x
(1)
< < x
(n)
;
Sommer les poids p
(k)
jusqu avoir : p
(1)
+ +p
(k+1)

1
2
;
k est alors le mdian pondr ;
n
Complexit :
(nlog n) comparaisons cause du tri
(n) additions dans la sommation
3 - Algorithme en temps linaire de calcul du mdian pondr
dbut
Poser E = { (x
i
, p
i
) } ;
si |E| = 1 alors termin : renvoyer x
1
;
Calculer le mdian x des x
i
, noter p son poids ;
Construire E
1
= { (x
i
, p
i
) / x
i
< x } ;
Construire E
2
= { (x
i
, p
i
) / x
i
> x } ;
Calculer S
1
=

E
1
p
i
;
si S
1
>
1
2
alors
relancer lalgorithme sur E
1
;
sinon
relancer lalgorithme sur E
2
{ (x, p +S
1
} ;
n
k est alors le mdian pondr ;
n
Lorsque lalgorithme est relanc, il faut rajuster tous les poids pour que leur somme fasse
toujours 1.
Calcul de I(n), complexit dune itration de lalgorithme, sans rcursivit :
Le calcul du mdian non pondr seectue en (n)
(cf. cours : algorithme faisant des paquets de cinq).
Les autres oprations seectuent en (n) galement.
= I(n) = (n)
Complexit totale : T(n) = T(
n
2
) +I(n) = T(
n
2
) + (n)
On peut alors appliquer le Master Theorem :
Notations : T(n) = a T(
n
b
) + (n

)
Valeurs : a = 1 ; b = 2 ; = 1
Cas : 1 = a < b

= 2
Conclusion : T(n) = (n

) = (n)
T(n) = (n) et on a donc un algorithme linaire pour calculer le mdian pondr.
81
Exercice 5.5.7. Le problme de lemplacement du bureau de poste
Considrons un espace mtrique (E, d). Soient n lments distincts x
1
, ..., x
n
de poids respectifs
p
1
, ..., p
n
tels que
i, p
i
0 et
n

i=1
p
i
= 1
On souhaite trouver un point x (qui nest pas ncessairement un des x
i
) qui minimise

n
i=1
p
i
d(x, x
i
).
1 - Cas de la dimension 1 : (E, d) est lensemble des rels muni de la distance usuelle. Montrer
que le mdian pondr est une des solutions optimales.
2 - Cas de la dimension 2 : (E, d) est le plan muni de la distance 1, ou distance Manhattan,
cest dire :
d((x
1
, y
1
), (x
2
, y
2
)) = |x
1
x
2
| + |y
1
y
2
|
Rsoudre lnonc qui sappelle dans ce cas problme du bureau de poste.
Correction.
On suppose les x
i
tris tels que x
1
< < x
n
.
1 - Il est vident que x [ x
1
; x
n
].
On note x
m
le mdian pondr des (x
i
, p
i
).
Soit x [ x
i
; x
i+1
] et > 0 avec x + [ x
i
; x
i+1
].
La situation est la suivante : x
i
x < x + x
i+1
S(x) =

n
k=1
p
i
|x x
i
|
La dnition de x impose que S(x) soit minimal.
S(x) =

x
k
< x
p
k
(x x
k
) +

x< x
k
p
k
(x
k
x)
S(x +) =

x
k
x
i
p
k
(x + x
k
) +

x
k
>x
i
p
k
(x
k
x )
= S(x) +
_

x
k
x
i
p
k

x
k
> x
i
p
k
_
= S(x) +
_

x
k
x
i
p
k
+

x
k
x
i
p
k
1
_
car :

n
k=1
p
k
= 1
S(x +) = S(x) +
..
> 0
_
2

x
k
x
i
p
k
1
_
S(x +) < S(x)

x
k
< x
i+1
p
k
<
1
2
Si x < x
i+1
< x
m
alors

x
k
< x
i+1
p
k
<

x
k
< xm
p
k
<
1
2
= S(x +) < S(x)
= S(x) nest pas minimal donc x nest pas un mdian pondr.
On en dduit : x x
m
.
En posant < 0, on montre avec un raisonnement similaire que x x
m
, ce qui permet de
conclure : x = x
m
. Corrolaire : lexercice 2 na pas servi rien !
2 - On calcule indpendamment x
k
mdian sur les x, et y
l
mdian sur les y.
La solution au problme est le point (x
k
, y
l
).
82
Note 1 : ne pas commettre lerreur de se limiter au calcul dun seul mdian et de dclarer
solution le point (x
k
, y
k
). En dimension 2, le point solution nest pas toujours confondable avec
un des P
k
comme ctait le cas dans la question prcdente.
Note 2 : cette solution simple convient car on utilise la distance de Manhattan. Elle ne
fonctionnerait pas avec la distance usuelle d(A, B) =
_
(x
A
x
B
)
2
+ (y
A
y
B
)
2
.
Exercice 5.5.8. Un nouvel algorithme de tri
Soit T un tableau contenant n entiers distincts, la procdure Nouveau_Tri est dnie de la
manire suivante :
Nouveau_Tri (T,i,j)
| si T[i] > T[j] alors changer les valeurs T[i] et T[j] ;
| si i j 2 alors faire
| k (j i + 1)/3| ;
| Nouveau_Tri(T, i, j k) ;
| Nouveau_Tri(T, i +k, j) ;
| Nouveau_Tri(T, i, j k) ;
1 - Montrer que Nouveau_Tri(T, 1, n) trie correctement le tableau T.
2 - Donner la complexit en nombre de comparaisons de cet algorithme. Comparer avec les
complexits des algorithmes de tri vus en cours (Rappel : ln(2) 0, 7 et ln(3) 1, 1).
Correction.
1 - Lalgorithme trie correctement.
Pour une longueur infrieure deux lalgo est rduit lchange ce qui donne un tableau
tri.
Pour i suprieur trois la premire ligne ne sert rien. On notera X Y si x X
y Y : x y. On pose l = |T|,on pose A lensemble des (
l+1
3
|) premier lment de T,
C lensemble des (
l
3
|) lment suivants , on pose B lensemble des (
l
3
|) dernier lment.
On commence par trier les lments de AC par induction : comme |AC| = (
2l
3
|) < l.
Donc on obtient A < C. On trie maintenant C B par induction : comme |A B|
(
2l
3
|) < l.Alors |B| |C| ce qui implique que si un lment b de B avant le tri se
retrouve dans B aprs, cest quil existe un lment c dans C avant le tri tel que c < b or
comme c est suprieur tous les lments de A b aussi donc aprs le tri C B et A B
ou encore C A B. Finalement on retrie AC et on obtient A < B < C avec A, B, C,
tri donc T est tri.
2 - Complexit
Pour trier un ensemble de n (n suprieur trois) lments on trie trois ensembles
2n
3
|
lments et on fait un change. Pour trier un ensemble de 2 lments on fait un change. Donc :
C(n) = 1 +C(
2n
3
|) et C(1) = 2
donc par master thorme :
C(n) = O(n
log
3
2
(3)
) O(n
2,75
)
Cest mauvais.
83
Exercice 5.5.9. Tas faibles & tri
Une technique classique de tri par comparaisons consiste utiliser la structure de donnes appele
tas binaire. Le tri correspondant a une complexit totale en 2nlog
2
(n)+O(n) comparaisons pour
n lments. Lobjectif de cet exercice est dtudier une variante de cette structure de donnes,
les tas faibles, pour amliorer la complexit et se rapprocher de la borne infrieure thorique.
Un tas faible pour n lments est un arbre binaire o chaque nud est tiquet par un lment,
et qui vrie les conditions suivantes :
(i) Les lments du sous-arbre droit de chaque nud sont infrieurs ou gaux llment associ
au nud.
(ii) La racine de larbre na pas de ls gauche.
(iii) Les feuilles se trouvent uniquement sur les deux derniers niveaux de larbre.
5 0 6 1
12 7
13
14
11
9
10 8
4 2
14 1 11 9 13 7 6
4 7 9 0 1 2 3 5 6 8 10 11 12 13
0
1
2 3
6 7
12 13
0 1 1 1 1 1 1 1 1 1 1 1
4 7 9 0 1 2 3 5 6 8 10 11 12 13
r
t
1
4 5
9 8 10 11
8 4 0 12 10
0
5 2
Fig. 5.3 Exemple de tas faible et un codage de cet arbre.
Pour coder cette structure de donnes, nous utiliserons deux tableaux t[0..n1] et r[0..n1]. Le
tableau t contiendra les n lments et le tableau r est un tableau de bits 0 ou 1 (qui permettra
de distinguer ls gauche et ls droit dun nud, et ensuite de les permuter faible cot). Plus
prcisment, avec le tableau t, le ls gauche de llment dindice i a pour indice 2i +r[i] et son
ls droit a pour indice 2i + 1 r[i] (on xe juste r[0] = 0 pour que la racine dindice 0 ait un
unique ls qui soit droite). Changer le bit r[i] revient alors changer ls droit et ls gauche de
llment dindice i et donc permuter le sous-arbre droit et le sous-arbre gauche de cet lment.
La gure 5.3 prsente un exemple de tas faible et de codage de cet arbre.
Les successeurs dun nud sur la branche gauche du sous-arbre droit sont appels ses petits-
ls. Par exemple sur la gure 5.3, les petits-ls de la racine sont les lments 11, 13 et 7. On
note Pere(i) lindice du pre du nud dindice i, et la fonction Gpere(i) (pour Grand-pre)
dnie par Gpere(Pere(i)) si i est le ls gauche de Pere(i) et par Pere(i) si i est le ls droit
de Pere(i). Par exemple avec le codage de la gure 5.3 le nud dindice 9 (de valeur t[9] = 2)
a pour grand-pre Gpere(9)= 1 (indice du nud avec la valeur t[1] = 11).
1 - Pour le codage de larbre avec les tableaux t et r, crire prcisment la fonction Gpere(i)
qui calcule lindice du grand-pre de llment dindice i dans t.
Soit echange(i,j) une fonction qui change les valeurs de t[i] et t[j]. Soit fusion(i,j) la fonction
dnie par : si (t[i] > t[j]) alors echange(i,j) et r[i] 1 r[i].
2 - Etant donn un tableau de n valeurs t[0..n1], on lui associe le tableau r = [0, 0, . . . , 0] o
tous les bits sont 0, et on eectue la fonction ConstruitTas(t,r) dnie par :
pour i de n 1 1, faire fusion(i,Gpere(i))
Montrer que pendant le droulement de la boucle, aprs avoir eectu fusion(i,Gpere(i)), alors
84
pour tout j i, les valeurs du sous-arbre de racine le nud dindice j sont toutes infrieures ou
gales la valeur du nud dindice Gpere(j). En dduire quen n de boucle, on obtient un tas
faible. Combien de comparaisons a-t-on eectu ?
3 - Etant donn un tas faible reprsent par les tableaux t et r, supposons que lon remplace
la valeur t[0] de la racine par une valeur quelconque, comment reconstruire rapidement un tas
faible avec cette valeur et quel cot en nombre de comparaisons ?
Indication : mettre jour en parcourant les petits ls de la racine.
4 - En dduire un algorithme de tri dun tableau t en nlog
2
(n) + O(n) comparaisons, qui
commence par construire un tas faible puis exploite cette structure de donnes.
Correction.
Laisse au lecteur.
5.6 Rfrences bibliographiques
Ce chapitre est un grand classique. Nous avons surtout utilis le livre de Froidevaux, Gaudel
et Soria [3] (cours et nombreux exercices. Lexercice Plus petit et plus grand est d Rawlins [8].
85
86
Chapitre 6
Graphes
6.1 Dnitions
Soit G = (V, E) un graphe non orient, o V est lensemble des sommets et E lensemble
des artes. On rappelle quelques dnitions lmentaires :
Degrs Le degr (v) dun sommet v V est le nombre dartes de E incidentes en v. Le degr
(G) du graphe G est le maximum des degrs dun sommet.
Chemin Soient u, v deux sommets de V . Un chemin de u v est un ensemble dartes e
1
, e
2
, . . . , e
k
de E telles que e
i
= (v
i1
, v
i
), v
0
= u et v
k
= v. Si tous les v
i
sont distincts, le chemin est
lmentaire. Si u = v, le chemin (lmentaire) est un cycle (lmentaire).
Composantes connexes Une composante connexe est une classe dquivalence de la relation
R dnie sur V V par uRv si et seulement sil existe un chemin de u v.Le graphe G
est connexe si tous les sommets sont dans la mme composante connexe.
Sous-graphe Un sous-graphe de G est un graphe (W, F) o W V , T E, et toutes les
artes de F relient deux sommets de W. Le sous-graphe induit par un sous-ensemble de
sommets comprend toutes les artes qui ont leurs deux extrmits dans ce sous-ensemble.
De mme pour le sous-graphe induit par un sous-ensemble dartes.
Dans le cas orient, on parle darcs au lieu dartes. On dnit le degr sortant et le degr
entrant dun sommet. Deux sommets u et v sont dans une mme composante connexe sil existe
un chemin de u v et un chemin de v u. Pour bien distinguer du cas non-orient, on parle
plutt de composante fortement connexe.
6.2 Arbres
6.2.1 Caractrisation
Dnition 5. Un arbre est un graphe connexe sans cycle.
Thorme 11. Soit G un graphe n sommets et m artes. On a lquivalence :
1. G est connexe sans cycle (dnition dun arbre)
2. G est connexe et minimal pour cette proprit (si on supprime une arte, G nest plus
connexe)
3. G est connexe et m = n 1
4. G est sans cycle et maximal pour cette proprit (si on ajoute une arte, G a un cycle)
5. G est sans cycle et m = n 1
87
6. Toute paire de sommets est relie par un chemin lmentaire et un seul
Preuve. La preuve est facile. Tout repose sur la construction suivante. On part des n sommets,
sans aucune arte. Il y a alors n composantes connexes, une par sommet. On ajoute les artes
une par une. Quand une ajoute une nouvelle arte, il y a deux cas :
Soit cette arte relie deux sommets qui ntaient pas dans la mme composante connexe.
Les composantes connexes de ces deux sommets fusionnent, et le nombre total de compo-
santes connexes diminue dune unit.
Soit cette arte relie deux sommets qui taient dj dans une mme composante connexe.
Elle cre un cycle (avec le chemin qui reliait les deux sommets). Le nombre total de
composantes connexes reste inchang.
On voit en particulier que pour passer de n composantes connexes une seule, il faut au
moins n 1 artes, et quaucune de celles-ci en cre de cycle.
Ce bout de preuve permet de montrer proprement que trouver le maximum de n lments
dans un ensemble muni dune relation dordre total exige de faire au moins n 1 comparisons.
En eet, on ajoute une arte entre deux lments quon compare. Sil reste deux (ou plus)
composantes connexes la n, le maximum peut se trouver dans nimporte laquelle.
6.2.2 Parcours darbres binaires
Il y a trois parcours classiques en profondeur :
Prxe (pre, ls gauche, ls droit)
Postxe (ls gauche, ls droit, pre)
Inxe (ls gauche, pre, ls droit)
Par contre, le parcours en largeur est un parcours niveau par niveau, de la racine jusquaux
feuilles. Cest une exploration "hirarchique" de larbre. Considrons lexemple :
28
25
21
3
8
6
20
13
12 3
Pour cet exemple, si on imprime le numro du sommet pre au moment o on le visite, on
trouve :
Prxe 20, 3, 3, 12, 8, 6, 13, 25, 21, 28
Postxe 3, 6, 8, 13, 12, 3,21, 28, 25, 20
Inxe 3, 3, 6, 8, 12, 13, 20, 21, 25, 28
88
Largeur 20, 3, 25, 3, 12, 21, 28, 8, 13, 6
On donne ci-dessous des programmes Java pour tous ces parcours.
Parcours prxe
class Arbre {
int contenu;
Arbre filsG;
Arbre filsD;
Arbre (int v, Arbre a, Arbre b) {
this.contenu = v;
this.filsG = a;
this.filsD = b;
}
static int taille(Arbre a) {
if (a == null)
return 0;
else
return 1 + taille (a.filsG) + taille (a.filsD);
}
static Arbre nouvelArbre(int v, Arbre a, Arbre b) {
return new Arbre (v, a, b);
}
public static void main(String args[]) {
Arbre a5, a7;
a5 = nouvelArbre (12, nouvelArbre (8, nouvelArbre (6, null, null), null),
nouvelArbre (13, null, null));
a7 = nouvelArbre (20, nouvelArbre (3, nouvelArbre (3, null, null), a5),
nouvelArbre (25, nouvelArbre (21, null, null),
nouvelArbre (28, null, null)));
prefixe(a7);
}
static void prefixe(Arbre a) {
if (a==null) return;
System.out.println(a.contenu+" ");
prefixe(a.filsG);
prefixe(a.filsD);
}
}
Les trois parcours en profondeur
class Arbre {
...
89
// parcours prfixe P G D
static void prefixe(Arbre a) {
if (a==null) return;
System.out.println(a.contenu+" ");
prefixe(a.filsG);
prefixe(a.filsD);
}
// parcours postfixe G D P
static void postfixe(Arbre a) {
if (a==null) return;
postfixe(a.filsG);
postfixe(a.filsD);
System.out.println(a.contenu+" ");
}
// parcours infixe G P D
static void infixe(Arbre a) {
if (a==null) return;
infixe(a.filsG);
System.out.println(a.contenu+" ");
infixe(a.filsD);
}
}
En profondeur (prxe) avec une pile
static void prefixeIter(Arbre a) {
if (a==null) return;
Pile P = new Pile();
P.push(a);
while (!P.estVide()) {
a = P.pop(); // imprime a.contenu
if (a.filsD != null) P.push(a.filsD);
if (a.filsG != null) P.push(a.filsG);
}
En largeur avec une le
static void largeurIter(Arbre a) {
if (a==null) return;
File F = new File();
F.fush(a);
while (!F.estVide()) {
a = F.pop(); // imprime a.contenu
if (a.filsG != null) F.fush(a.filsG);
if (a.filsD != null) F.fush(a.filsD);
}
90
6.2.3 Arbres binaires de recherche
Dans un arbre binaire de recherche, on impose un ordre partiel sur les contenus : les nuds
du sous-arbre gauche (resp : droit) ont une valeur infrieure ou gale (resp : suprieure) la
valeur du pre :
valeur[sous-arbre gauche] valeur[nud] < valeur[sous-arbre droit]
On veut que les procdures de recherche, dinsertion dun nouveau nud, et de suppression
dun nud, aient un cot proportionnel la hauteur de larbre. Cest facile pour les deux
premires, mais cela demande une analyse plus ne pour la suppression : comment reconstruire
larbre ? Voici la mthode :
Pour supprimer la cl x de larbre a, on cherche dabord le sommet s dont la cl vaut x.
Quand on la trouv, il faut disposer dune mthode pour supprimer la racine du sous-arbre
de s :
1. Si s na quun ls unique, on le remplace par celui-ci.
2. Sinon, il faut chercher le sommet t qui est le prdcesseur de la racine (au sens de
lordre sur les cls). On remplace alors la cl de s par celle de t, et on supprime t.
Lemme : t na pas de ls droit.
Le prdcesseur est donc le "dernier" ls droit en descendant la chane partir du ls
gauche de la racine.
On donne ci-dessous des programmes Java pour les trois oprations.
Recherche
static Arbre recherche(int v, Arbre a) {
if (a == null || v == a.contenu)
return a;
else
if (v < a.contenu)
return recherche(v, a.filsG);
else
return recherche(v, a.filsD);
}
static boolean estDans(int v, Arbre a) {
return (recherche(v,a) != null);
}
Insertion
static Arbre ajouter(int v, Arbre a) {
if (a == null)
a = nouvelArbre(v, null, null);
else if (v <= a.contenu)
a.filsG = ajouter(v, a.filsG);
else
a.filsD = ajouter(v, a.filsD);
return a;
}
91
static Arbre ajouterSansModif(int v, Arbre a) {
if (a == null)
a = nouvelArbre(v, null, null);
else if (v <= a.contenu)
return nouvelArbre(v, ajouter(v, a.filsG), a.filsD);
else
return nouvelArbre(v, a.filsG, ajouter(v, a.filsD));
}
Suppression
static Arbre supprimer(int v, Arbre a) {
if (a == null) return a;
if (v == a.contenu)
return eliminerRacine(a);
if (v < a.contenu)
a.filsG = supprimer(v, a.filsG);
else
a.filsD = supprimer(v, a.filsD);
return a;
}
static Arbre dernierFils(Arbre a) {
if (a.filsD == null)
return a;
else
return dernierFils(a.filsD);
}
static Arbre eliminerRacine(Arbre a) {
if (a.filsG == null)
return a.filsD;
if (a.filsD == null)
return a.filsG;
Arbre b = dernierFils(a.filsG);
a.contenu = b.contenu;
a.filsG = supprimer(a.contenu, a.filsG);
return a;
}
Version itrative de la suppression
static Arbre supprimerI(int v, Arbre a) {
if (a == null) return a;
if (v == a.contenu)
return eliminerRacineI(a);
if (v < a.contenu)
a.filsG = supprimerI(v, a.filsG);
else
92
a.filsD = supprimerI(v, a.filsD);
return a;
}
static Arbre eliminerRacineI(Arbre a) {
if (a.filsG == null)
return a.filsD;
if (a.filsD == null)
return a.filsG;
Arbre g = a.filsG;
Arbre h = g.filsD;
if (h == null) { // g na pas de fils droit
a.contenu = g.contenu; // transfert de cl
a.filsG = g.filsG; // suppression de g
return a;
}
while (h.filsD != null) { // descente branche droite
g = h;
h = h.filsD; // h fils droit de g
}
a.contenu = h.contenu; // transfert de cl
g.filsD = h.filsG; // suppression de h
return a;
}
Pour terminer avec les arbres de recherche, voici un petit exercice. Soit A un arbre de
recherche. Montrer que :
1. Le parcours inxe ordonne les noeuds par valeur croissante.
2. Si un noeud a deux ls, son successeur dans lordre inxe na pas de ls gauche et son
prdcesseur (dans lordre inxe) na pas de ls droit.
3. Montrer que le successeur dun noeud n est le sommet le plus gauche dans le sous-arbre
droit issu de n.
6.3 Structures de donnes pour les graphes
Pour reprsenter un graphe en machine, plusieurs structures de donnes sont utilises, no-
tamment matrices ou listes de successeurs. La complexit des algorithmes dpendra de la repr-
sentation choisie, do la ncessit de la choisir soigneusement.
Dans cette section, on utilise les notations suivantes :
G = (V, E), V sommets et E artes (ou arcs dans le cas orient),
Le nombre de sommets est n = |V |,
Le nombre dartes est m = |E| (m = O(n
2
)).
Matrice dadjacence
M
i,j
=
_
O si (i, j) / E
1 si (i, j) E
M est symtrique si le graphe est non-orient
Utilisation : accessibilit, plus courts chemins (proprits globales du graphe).
93
Matrice dincidence
Pour un graphe orient sans boucle
Taille n m
M
i,a
=
_
_
_
1 si i est lorigine de a
1 si i est lextrmit de a
0 sinon
Utilisation : branchements, programmation linaire
Exercice : M est totalement unimodulaire : le dterminant de toute sous-matrice carre
de M vaut 0, 1 ou 1.
Listes de successeurs
Pour chaque sommet, la liste de ses successeurs
On a un tableau de taille n pour les dbuts de liste
Deux variantes :
GrapheSucc si tous les sommets ont peu prs le mme nombre de sucesseurs : on
stocke ceux-ci dans un tableau, avec une sentinelle Omega = -1 pour marquer le dernier
successeur
GrapheListe une vraie structure de liste
Utilisation : parcours dans tous les sens, connexit
Structures de donnes en Java
class GrapheMat {
int m[][];
int nb;
GrapheMat(int n1) {
// Initialisation: n1 sommets, matrice vide
nb = n1;
m = new int[n1][n1];
}
GrapheMat (int n1, int p) {
// Initialisation: n1 sommets, matrice
// Pour un arc entre i et j: proba 1/p dexister
nb = n1;
m = new int[n1][n1];
for (int i = 0; i < nb; ++i)
for (int j = 0; j < nb; ++j) {
int a = (int) (Math.random() * p);
if (a == p - 1 ) m[i][j] = 1;
else m[i][j] = 0;
}
}
static void imprimer (GrapheMat g) {
System.out.println ("nombre de sommets " + g.nb);
for (int i = 0; i < g.nb ; ++i) {
for (int j = 0; j < g.nb; ++j)
System.out.print (g.m[i][j] + " ");
94
System.out.println ();
}
System.out.println ();
}
}
class GrapheSucc{
int succ[][];
int nb;
final static int Omega = -1;
GrapheSucc(int n) {
nb = n;
succ = new int[n][n];
}
static void imprimer(GrapheSucc g) {
System.out.println ("nombre de sommets " + g.nb + " ");
for (int i = 0; i < g.nb; ++i)
{ System.out.println ("sommet " + i + ", : successeurs: ");
for (int j = 0; g.succ[i][j] != Omega; ++j)
System.out.print (g.succ[i][j] +" ");
System.out.println ();
}
System.out.println();
}
}
class GrapheListe{
Liste listeSucc[];
int nb;
GrapheListe (int n1) {
nb = n1;
listeSucc = new Liste[n1];
}
static void imprimer (GrapheListe g) {
System.out.println ("nombre de sommets " + g.nb);
for (int i = 0; i < g.nb; ++i) {
System.out.println ("sommet " + i + ", : successeurs: ");
for (Liste u = g.listeSucc[i]; u != null; u = u.suivant)
System.out.print (" " + u.contenu);
System.out.println ();
}
System.out.println ();
}
95
}
Comparaison Pour un graphe n sommets et m arcs, la taille mmoire ncessaire est :
Matrice dadjacence : n
2
.
Matrice dincidence : n m.
Liste de successeurs : n +m.
Conversions
GrapheMat (GrapheSucc h) {
// Matrice de successeurs -> matrice dadjacence
nb = h.nb;
m= new int[nb][nb];
for (int i = 0; i < nb ; ++i)
for (int j = 0; j < nb ; ++j) m[i][j] = 0;
for (int i = 0; i < nb ; ++i)
for (int k = 0; h.succ[i][k] != GrapheSucc.Omega; ++k)
m[i][h.succ[i][k]] = 1;
}
GrapheSucc (GrapheMat g) {
// Matrice dadjacence -> matrice de successeurs
nb = g.nb;
int nbMaxSucc = 0;
int temp = 0;
for (int i = 0; i < nb ; ++i) {
for (int j = 0; j < nb ; ++j)
if (g.m[i][j] != 0) temp++;
nbMaxSucc = Math.max (nbMaxSucc, temp);
temp = 0;
}
succ = new int[nb][nbMaxSucc + 1];
for (int i = 0; i < nb ; ++i) {
int k = 0;
for (int j = 0; j < nb ; ++j)
if (g.m[i][j] != 0)
succ[i][k++] = j;
succ[i][k] = Omega;
}
}
GrapheListe (GrapheSucc g) {
// Matrice de successeurs -> tableau de listes de successeurs
nb = g.nb;
listeSucc = new Liste[nb];
for (int i = 0; i < nb ; ++i) {
listeSucc[i] = null;
for (int k = 0; g.succ[i][k] != GrapheSucc.Omega; ++k)
listeSucc[i] = Liste.ajouter(g.succ[i][k], listeSucc[i]);
}
96
}
6.4 Accessibilit
6.4.1 Rappels sur les relations binaires
Soit E un ensemble ni, n = |E|, et R une relation binaire (cest--dire une partie de EE).
Pour un lment {(x, y)} R on crira aussi xRy. On dnit par rcurrence llvation la
puissance R
i
:

R
i
= R R
i1
R
0
= id
Par exemple, R
2
= { (x, z) / y , xRy yRz}.
Lemme 7. p, q/ 0 p < q 2
(n
2
)
tq R
p
= R
q
Preuve. Il y a autant de relations binaires que de parties de E E. Comme |E E| = n
2
, il y
a exactement 2
(n
2
)
relations binaires.
Dnition 6. - Soit S est une relation binaire ; on dit que S est transitive S
2
S.
- Soit R est une relation binaire ; on dnit la fermeture transitive R
+
par :
R
+
=

SR
Stransitive
S
Remarque 1. il existe au moins une relation transitive S contenant R (notamment x, y, xSy).
lintersection de deux relations transitives est transitive.
Proposition 2. xR
+
y
p > 0 | x
1
. . . x
p
E avec x
1
= x, x
p
= y et x
i
Rx
i+1
pour 1 i p
ce qui peut aussi scrire : R
+
=
_
p1
R
p
Preuve. Nommons xCy la relation chemin de R. Montrons que C = R
+
:
R
+
C : C contient R et C est transitive, donc C est un des termes de lintersection dans
la dnition de R
+
.
C R
+
: xons un chemin de x y, et soit S transitive et contenant R. Comme S contient
R, S doit contenir tous les arcs du chemin considr ; et comme S est transitive, S doit
contenir le couple (x, y). Maintenant R
+
est lintersection de tels relations S, donc (x, y)
est dans R
+
.
Proposition 3.
(1) R
n

_
0in1
R
i
et (2) p 1, R
p

_
1in
R
i
97
Preuve. 1. Soit S =

0in1
R
i
et supposons aR
n
b, on va montrer qualors aSb. Il existe
x
0
, . . . , x
n
E, x
0
= a, x
n
= b, x
i
Rx
i+1
pour 0 , i < n. On a n + 1 valeurs de x donc
il existe p et q tels que x
p
= x
q
, avec 0 p < q n. Si p = 0 et q = n, alors a = b donc
aR
0
b donc aSb. Sinon, on a aR
p
x
p
= x
q
= R
nq
x
n
, donc aR
s
b avec s = n+p q n1,
et aSb.
2. Par rcurrence sur p :
p = 1 : R
1

1in
R
i
p p + 1 :
on vient de montrer que R
n

0in1
R
i
, donc

0in
R
i

0in1
R
i
si par hypothse de rcurrence R
p

1in
R
i

0in1
R
i
,
alors en composant par R on a
R
p+1

1in
R
i
Dnition 7. Fermeture reexive et transitive :
R

= Id R
+
=
_
0in1
R
i
6.4.2 Chemins dans les graphes
Soit M la matrice dadjacence de G = (V, E). On considre ses coecients comme des
entiers.
Lemme : soit M
p
la puissance p-me de M. Le coecient M
p
ij
est gal au nombre de
chemins de longueur p de v
i
v
j
Preuve par rcurrence :
Vrai par dnition pour p = 1
M
p
ij
=

n
k=1
M
p1
ik
.M
kj
, cette relation exprime toutes les dcompositions possibles dun
chemin de longueur p en un chemin de longueur p 1 suivi dune dernire arte
Notons que si on considre les coecients de M comme des boolens, M
p
donne lexistence
dun chemin de longueur p (cf. ce qui prcde).
6.4.3 Fermeture transitive
Algorithme naf
G
+
= (V, A
+
) dni par
(i, j) A
+
il y a un chemin non vide de v
i
v
j
dans G
M
+
= M +M
2
+. . . +M
n
est la fermeture transitive
M

= I +M
+
est la fermeture rexive et transitive
Cot de calcul de M
+
en O(n
4
) car on doit faire n multiplications de matrices
Cot de calcul de M

en O(n
3
log n) car on peut calculer plus : log n| lvations suc-
cessives au carr de I +M (cest lalgorithme dexponentiation binaire vu Section 1.3)
Algorithme de Roy-Warshall Lalgorithme de Roy-Warshall rsout le problme de fer-
meture transitive dun graphe. Au passage, ce problme est clairement un sous-problme du
problme de plus court chemin. Il sut pour le montrer de prendre tous les poids des artes
gaux 0. Dans une telle situation, (u, v) vaut 0 sil existe un chemin entre u et v, et vaut +
dans le cas contraire. Cest ce qui permetttra dtendre facilement lalgorithme pour traiter des
plus courts chemins dan sun graphe sans cycle de poids ngatif.
98
Proposition 4. La rcurrence A
(p)
ij
= A
(p1)
ij
+A
(p1)
ip
A
(p1)
pj
initialise avec A
(0)
= M, calcule
M
+
= A
(n)
.
Preuve. La preuve est fonde sur lide que A
(p)
ij
= 1 si et seulement sil existe un chemin de i
j dont tous les sommets intermdiaires sont de numro infrieur ou gal p. Ce qui se dmontre
par rcurrence sur p.
Initialisation p = 0 : on nutilise aucun sommet intermdiaire, donc les chemins sont rduits
aux artes du graphe, et on a bien pos A
(0)
= M.
Le premier sens de lquivalence est vri par construction. Si A
(p)
ij
= 1, alors on a au moins
une des galits A
(p1)
ij
= 1 ou A
(p1)
ip
A
(p1)
pj
= 1, qui traduisent toutes deux lexistence
dun chemin de longueur infrieure ou gale p, entre i et j, par hypothse de rcurrence.
Pour la rciproque, prenons un chemin de i j de longueur infrieure ou gale p, et
montrons que A
(p)
ij
= 1 :
Si ce chemin passe par le sommet p, on a i p j, avec i p et p i tant deux
chemins dont tous les sommets intermdiaires sont de numro strictement infrieur p.
Par hypothse de rcurrence, A
(p1)
ip
= 1 et A
(p1)
pj
= 1.
Si ce chemin ne passe pas par le sommet p, tous les sommets intermdiaires de ce chemin
sont de numro strictement infrieur p, et par hypothse de rcurrence, A
(p1)
ij
= 1.
Algorithme de Roy-Warshall
A M
pour p = 1 n
pour i = 1 n
pour j = 1 n
A
ij
A
ij
+A
ip
A
pj
Cet algorithme seectue en place, cest--dire que lon travaille sur une seule matrice A pour
calculer successivement les A
(p)
. Il y a deux manires de justier cela.
La premire consiste dire que la matrice A ne fait que crotre (on nenlve pas de 1), et
que donc la n de lalgorithme A
(n)
M
+
, et comme par construction on vrie toujours
A M
+
, on a bien A = M
+
la n.
La seconde justication sappuie sur une rcriture de lalgorithme :
A M
pour p = 1 n
pour i = 1 n
si A
ip
alors
pour j = 1 n
si A
pj
alors
A
ij
1
Pour montrer lquivalence des deux algorithmes, on discute selon la valeur de A
ip
. Premier
cas : A
ip
= 1. On fait alors A
ij
A
ij
+ A
pj
pour tout j. Lorsque j = p, on ne change pas
A
ip
qui vaut dj 1. Second cas : A
ip
= 0. Il ny a alors aucune modication de faite sur A :
A
ij
A
ij
+ 0A
pj
, et ce mme lorsque j = p.
Lalgorithme de Roy-Warshall est en O(n
3
). Pour calculer la fermeture rexive, on part de
A
(0)
= M, mais pour la fermeture rexive et transitive, on part de A
(0)
= I +M.
99
Implmentation
static void multiplier (int c[][], int a[][], int b[][]) {
int n = c.length;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
c[i][j] = 0;
for (int k = 0; k < n; ++k)
c[i][j] = c[i][j] + a[i][k] * b[k][j];
}
}
static void additionner (int c[][], int a[][], int b[][]) {
int n = c.length;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
c[i][j] = a[i][j] * b[i][j];
}
static boolean existeChemin (int i, int j, GrapheMat g) {
int n = g.nb;
int m[][] = g.m;
int u[][] = (int[][]) m.clone();
int v[][] = new int[n][n];
for (int k = 1; u[i][j] == 0 && k <= n; ++k) {
multiplier (v, u, m);
additionner (u, u, v);
}
return u[i][j] != 0;
}
static public void fermetureTransitive(GrapheMat g) {
for (int k = 0; k < g.nb; ++k)
for (int i = 0; i < g.nb; ++i)
if (g.m[i][k] == 1)
for (int j = 0; j < g.nb; ++j)
if (g.m[k][j] == 1)
g.m[i][j] = 1;
}
static public void fermetureReflexiveTransitive (GrapheMat g) {
for (int i = 0; i < g.nb; ++i)
g.m[i][i] = 1;
for (int k = 0; k < g.nb; ++k)
for (int i = 0; i < g.nb; ++i)
if (g.m[i][k] == 1)
for (int j = 0; j < g.nb; ++j)
if (g.m[k][j] == 1)
g.m[i][j] = 1;
}
100
6.5 Plus courts chemins
6.5.1 Dnitions
Donnons-nous un graphe G = (V, E), avec V lensemble des sommets, et E (V V )
lensemble des artes.
On suppose dans toute la partie que le graphe est stock par sa matrice dadjacence M. Ainsi
M
ij
= 1 (i, j) E. Cette reprsentation nest pas la seule possible, on pourrait par exemple
utiliser des listes dadjacence ou encore une listes dartes. Il faut bien noter que la complexit
des algorithmes peut dpendre de la reprsentation choisie.
Dnition 8. Une pondration est une fonction w : E R, et w(i, j) correspond au
poids de larte (i, j).
Le poids dun chemin est la somme des poids des artes qui composent ce chemin. Si p est
un chemin passant par les sommets x
i
, alors
w(p) =
p1

i=1
w(x
i
, x
i+1
)
Soit (u, v) le poids du plus court chemin de u v. En notant p : u v un chemin p
allant de u v,
(u, v) = min
p : uv
w(p)
Quelques prcisions :
1. Lensemble des chemins de u v peut tre vide, cela voulant dire quil nexiste aucun
chemin de u v. Dans ce cas, on posera (u, v) = +.
2. Lensemble des chemins de u v est potentiellement inni, et on ne peut prendre le min
de cet ensemble sans prcautions.
Sil nexiste aucun circuit de poids ngatif dans G, on peut alors se restreindre aux
chemins lmentaires, qui sont eux en nombre ni. En eet, supposons que le chemin le
plus court contienne une boucle. En enlevant cette boucle, qui selon notre supposition
est de poids positif, on obtient un chemin plus court. Le chemin le plus court est donc
ncessairement un chemin lmentaire.
Sil existe un chemin de u v qui contient un circuit de poids strictement ngatif, alors
on peut construire un chemin de poids arbitrairement petit. Il sut pour cela de boucler
sur le circuit un nombre susant de fois : chaque fois que lon rajoute une boucle,
on dcrot le poids du chemin du poids de cette boucle. Dans un tel cas, on posera
(u, v) = .
Remarque 2. Si tous les poids sont positifs, on est sr quil ne peut y avoir de circuit de poids
ngatif. Cette condition susante est souvent utilise.
Remarque 3. Un algorithme qui traite le cas gnral doit tre capable de dtecter les circuits
de poids ngatif lorsquils sont accessibles.
6.5.2 Prsentation des plus courts chemins
Il y a trois problmes de plus court chemin :
1. calculer le plus court chemin entre une source u et une destination v,
2. calculer les plus courts chemins entre une source u et tous les autres sommets du graphe,
101
3. calculer tous les plus courts chemins entre les sommets du graphe pris deux deux.
Premier rsultat qui peut surprendre au dbut : dans le pire cas, pour rsoudre le problme
1, il faut rsoudre le problme 2. En dautres termes, on ne connat pas dalgorithme qui rsolve
1 sans rsoudre 2, dans le pire cas. Le second rsultat est quon peut rsoudre le problme 3 plus
ecacement quen rsolvant le problme 2 pour chaque source.
On commencera par rsoudre le problme 3, sans doute le plus simple, avec lalgorithme de
Warshall-Floyd. Ensuite, on abordera lalgorithme de Dijkstra, ecace pour les problmes 1 et
2.
Remarque 4. Il existe une multitude dalgorithmes de plus courts chemins adapts des types de
graphes particuliers : graphes sans circuits (acyclic graph), graphes orients sans circuit (directed
acyclic graph = DAG), graphes creux, cest--dire avec peu dartes par rapport au nombre de
sommets (sparse graphs).
Toutes les dmonstrations sont bass sur la proposition fondamentale de sous-structure op-
timale qui suit.
Proposition 5. Si u v est un plus court chemin de u v, et si w est un sommet sur ce
chemin (on a donc u w v), alors u w et w v sont des plus courts chemins.
Preuve. Triviale par labsurde. Si on trouvait par exemple un chemin plus court pour aller u
w, on pourrait lutiliser pour construire un chemin plus court pour aller de u v.
6.5.3 Avec des poids positifs
Pour calculer les plus courts chemins entre toutes les paires de sommets, lalgorithme de
Roy-Warshall se gnralise aux plus courts chemins quand les poids sont positifs :
Chaque arc (i, j) est pondr dun poids c(i, j) 0. On pose c(i, j) = + si (i, j) / E.
Il ny a donc pas de circuit de poids ngatif, les plus courts chemins existent bien.
On peut se restreindre aux chemins lmentaires.
On pose a(i, j) = c(i, j) si i ,= j, et a(i, i) = 0.
On dnit a
k
(i, j) plus court chemin de v
i
v
j
dont tous les sommets intermdiaires sont
k.
Rcurrence : a
k
(i, j) = min(a
k1
(i, j), a
k1
(i, k) +a
k1
(k, j)).
Implmentation trs similaire (attention la somme avec +).
Remarque 5. Pour linstant, le programme se contente de retourner la longueur du plus court
chemin. Si on veut rcuprer un plus court chemin (il peut y en avoir plusieurs), on peut utiliser
une matrice auxiliaire P pour retenir la provenance, dnie ainsi :
P
ij
contient le numro du dernier sommet intermdiaire dun plus court chemin allant de
i j,
P
ij
= i sil ny a pas de sommet intermdiaire sur ce chemin,
P
ij
= NULL sil ny a pas de chemin de i j.
6.5.4 Chemins algbriques dans les semi-anneaux
Pour le cas gnral, si les poids sont arbitraires, il peut y avoir des circuits de poids ngatifs,
et le plus court chemin nest pas dni (ou plutt, prend la valeur ). Il sagit de gnraliser
Floyd-Warshall pour obtenir un algorithme qui calcule la longueur des plus courts chemins entre
toutes les paires de sommets en tenant compte des circuits de poids ngatifs, aussi appels
circuits absorbants.
102
Soit un semi-anneau (H, , ). Rappel : dans un semi-anneau il ny a pas forcment doppos
toutes les valeurs, contrairement aux anneaux. On dnit lopration toile par a

=

+
i=0
a
i
pour tout a H. En xant astucieusement des semi-anneaux, on retrouvera dabord Roy-
Warshall, puis on dduira lalgorithme de Warshall-Floyd avec circuits absorbants.
La relation de rcurrence sur laquelle se base lalgorithme est lgrement modie an de
prendre en compte les circuits absorbants :
A
(p)
ij
= A
(p1)
ij
( A
(p1)
ip
(A
(p1)
pp
)

A
(p1)
pj
)
Le calcul de (A
(p1)
pp
)

na besoin dtre eectu quune seule fois par itration sur p, et celui
de A
(p1)
ip
(A
(p1)
pp
) quune seule fois par itration sur i. En faisant apparatre ces factorisations,
on obtient lalgorithme qui suit.
Algebraic Path Problem (APP)
A M
pour p = 1 n
A
(p)
pp
(A
(p1)
pp
)

pour i = 1 n, i ,= k
A
(p)
ip
= A
(p1)
ip
A
(p)
pp
pour j = 1 n, j ,= k
A
(p)
ij
= A
(p1)
ij
(A
(p)
ip
A
(p1)
pj
)
A
(p)
pj
= A
(p)
pp
A
(p1)
pj
Pour lalgorithme de Roy-Warshall, on utilise :

H = {0, 1}
= ou logique
= et logique
a, a

= 1
Pour lalgorithme de Warshall-Floyd avec gestion des circuits absorbants, on utilise :

H = R {+, }
= min
= +
a

=
_
0 si a > 0
sinon
Enn, tant donne une matrice relle A, on peut calculer la matrice (I A)
1
par lalgo-
rithme de Gauss-Jordan : on pose H = (R, +, ) et a

=
1
1a
si a ,= 1.
Il est surprenant que chercher des plus courts chemins dans des graphes et inverser des
matrices soient en fait deux facettes dun mme problme ! La preuve de ces rsultats est laisse
au soin du lecteur motiv.
6.5.5 Algorithme de Dijkstra
On sintresse maintenant au problme des plus courts chemins partir dune source donne.
Lalgorithme de Dijkstra que lon tudie ici ne fonctionne que sur les graphes o tous les poids
sont positifs. Pour les autres, on peut utiliser lalgorithme de Bellman-Ford (voir le Cormen).
Soit G(V, E, w) un graphe orient, dont les sommets sont numrots V = 1, 2, . . . , n et avec
la source tant le sommet 1. On note (i) lensemble des voisins du sommet i, ce qui scrit
(i) = {j / (i, j) E}.
Algorithme de Dijkstra
S {1}
103
d(i) = w(1, i) si i (1), et + sinon
tant que S ,= V
Soit j tel que j / S et d(j) = min
iS
d(i)
S S {j}
pour tout k (j) vriant k / S
d(i) min{ d(i) , d(k) +w(k, i) }
Il sagit dun algorithme entirement glouton, qui ajoute S les points un par un, dans
lordre de leur distance au sommet 1. S correspond lensemble des sommets i pour lesquels
(1, i) est dtermin. Lors de lajout dun somment j S, on met jour les distances des voisins
de j.
Voici un example :
1
4
5
6
3
2
1
1
2
2
3
4
5
5
7
7
Droulons les tapes de lalgorithme de Dijkstra sur ce graphe. Le tableau qui suit contient
les valeurs des d(i) pour tous les sommets i (en colonnes), au l des tapes (en lignes). A chaque
tape, la valeur d(j) correspondante au sommet j ajout S est marque en gras.
tape / i 1 2 3 4 5 6
0 0
1 . 7 1
2 . 6 . 3 8
3 . 5 . 8 . 8
4 . 5 . 8 . 8
5 . . . 8 . 6
6 . . . 8 . .
(1, i) 0 5 1 8 3 6
Preuve. Il faut procder rigoureusement, car il est trs facile de donner une preuve fausse de
cet algorithme. On notera d

(i) la place de (1, i) pour dsigner le poids du plus court chemin


de la source au sommet i. Linvariant snonce ainsi :

si i S, d(i) = d

(i)
si i / S, d(i) = min
kS
i(k)
{d(k) +w(k, i)}, ou +si indni
Dmontrons cet invariant par rcurrence sur le cardinal de S, en discutant selon la nature
des sommets : ceux qui restent dans S, celui qui rentre dans S, et ceux qui restent dans V S.
104
Pour tout sommet i qui reste dans S, on conserve d(i) = d

(i).
Considrons un j qui rentre dans S, cest--dire vriant j / S et d(j) = min
iS
d(i).
Lobjectif est de prouver que d(j) = d

(j).
1. Considrons un plus court chemin de la source au sommet j.
2. Dcomposons en
1
+
2
(concatnation de chemin), avec
1
chemin de 1 k o k
est le premier sommet de qui nest pas dans S.
3. Comme tous les poids sont positifs, w(
2
) 0, et donc w() w(
1
).
4. Daprs lhypothse de rcurrence applique k / S, d(k) est infrieur au poids
de tout chemin de 1 k dont tous les sommets intermdiaires sont dans S, donc
w(
1
) d(k).
5. Mais par dnition de j, d(j) = min
iS
d(i), et donc d(k) d(j).
6. Par transitivit, w() d(j), donc d(j) est infrieur au poids dun plus court chemin
de 1 j, et par consquent d(j) est le poids du plus court chemin, ce qui se traduit
d(j) = d

(j).
Les sommets i qui restent dans V S sont de deux catgories :
si i / (j), alors d(i) est inchang.
si i (j), alors d(i) est correctement mis jour par lalgorithme.
Ceci clot la dmonstration de la correction de lalgorithme de Dijkstra.
Complexit de lalgorithme de Dijkstra Commenons par une majoration grossire. Il y a
au plus n tapes correspondant des insertions dun sommet supplmentaire dans S. chaque
tape, il faut :
trouver le j / S qui minimise d(j), ce qui peut se faire navement en regardant tous les
sommets de V S, donc en moins de n oprations.
propager sur tous les voisins du j considr, ce qui est de lordre de |(j)|, l encore major
par n. La complexit de lalgorithme est donc majore par O(n
2
).
Cette complexit est optimale pour les graphes denses. Dans le pire cas, pour un graphe qui
possde n
2
artes, il faudra considrer toutes les artes. En revanche, pour les graphes creux,
lutilisation dun tas amliore la complexit. En notant m le nombre dartes :
chaque tape, la rcupration du minimum peut se faire en log n si on utilise un tas,
donc au total nlog n,
chaque arrte sera propage au plus un fois, et chaque propagation il faut mettre jour
la valeur dans le tas en log n, ce qui fait au total moins de mlog n.
La complexit dune implmentation avec un tas pour un graphe donne par les listes dad-
jacences des sommets est donc O
_
(n +mp) log n
_
.
Ainsi, our les graphes dont le degr sortant des sommets est major par une petite constante,
comme m est en O(n), on a un algorithme de plus court chemin en O(nlog n). Il existe une
structure avance appele tas de Fibonnacci qui permet de dcrotre des valeurs dans le tas en
une complexit amortie O(1). Avec cette structure, lalgorithme de Dikjstra est en O(nlog n+m).
6.6 Parcours en largeur
Cahier des charges
G = (V, E) graphe orient n = |V | sommets et m = |E| artes.
On se donne une racine r et on cherche une arborescence des plus courts chemins partir
de r : sommets x tels quil existe un unique chemin de r x.
Ide : faire un parcours en largeur ( laide dune le)
105
Implmentation
class Arbo{
int pere[];
final static int Omega = -1;
Arbo (int n, int r) {
// initialisation dune arborescence de racine r
pere = new int[n];
for (int i = 0; i < n ; ++i)
pere[i] = Omega;
pere[r] = r;
}
Arbo (GrapheSucc g, int r) {
// conversion de reprsentation
// calcul des pres si g est une arboresence donne en
liste de successeurs
// attention: il peut y avoir des cycles
pere = new int[g.nb];
pere[r] = r;
for (int i = 0; i < g.nb ; ++i)
for (int k = 0; g.succ[i][k] != GrapheSucc.Omega; ++k)
pere[g.succ[i][k]] = i;
}
static void imprimer (Arbo a) {
System.out.println ("nombre de sommets " + a.pere.length + " ");
for (int i = 0; i < a.pere.length; ++i)
System.out.println ("sommet " + i + ", : pere: " + a.pere[i]);
}
static int[] numPrefixe (int r, GrapheSucc g) {
// gnralise la numrotation des arbres binaires
// parcours Pre 1erFils 2meFils ... dernierFils
int numero[] = new int[g.nb];
numPrefixe1 (r, g, numero, 0);
return numero;
}
static void numPrefixe1 (int x, GrapheSucc g, int numero[], int num) {
numero [x] = num++;
for (int i = 0; g.succ[x][i] != GrapheSucc.Omega; ++i)
numPrefixe1 (g.succ[x][i], g, numero, num);
}
static Arbo arbPlusCourt (GrapheSucc g, int r) {
// ici g est un graphe quelconque
Arbo a = new Arbo(g.nb, r);
File f = new File.vide();
106
File.ajouter(r, f); // d[r] = 0
while (!File.estVide(f)) {
int x = File.valeur(f);
File.supprimer(f);
for (int i = 0; g.succ[x][i] != GrapheSucc.Omega; ++i) {
int y = g.succ[x][i];
if (a.pere[y] == Omega) {
a.pere[y] = x; // d[y] = d[x] + 1
File.ajouter(y, f);
}
}
}
return a;
}
}
Complexit
Parcours en temps O(n +m) car :
1. chaque sommet est empil/dpil au plus une fois,
2. chaque arc est explor au plus une fois,
Aprs le parcours, x est atteignable pere[x] ,= Omega (et sa distance r est d[x]).
Nouvelle solution lexistence dun chemin dun point un autre.
6.7 Parcours en profondeur
6.7.1 Premire version
Cahier des charges
G = (V, E) graphe orient n = V sommets et m = E artes.
On se donne une racine r et on cherche une arborescence de Trmaux, i.e. un parcours en
profondeur du graphe partir de r
Version rcursive naturelle ou utilisation dune pile.
Implmentation
class Parcours{
final static int Omega = -1;
static void tremaux(int x, GrapheSucc g) {
// parcours en profondeur de racine x
tremauxRec(x, g, new Arbo(g.nb, x));
}
static void tremauxRec(int x, GrapheSucc g, Arbo a) {
for (int k = 0; g.succ[x][k] != Omega; ++k) {
int b = g.succ[x][k];
if (a.pere[b] == Omega) {
a.pere[b] = x;
tremauxRec(b, g, a);
107
}
}
}
static void tremauxPile(int x, GrapheSucc g, Arbo a) {
int y, z;
Pile p = new Pile();
Pile.ajouter (x, p);
a.pere[x] = x;
boucle:
while ( !Pile.estVide(p) ) {
y = Pile.valeur (p);
for (int k = 0; g.succ[y][k] != GrapheSucc.Omega; ++k) {
z = g.succ[y][k];
if (a.pere[z] == Omega)
a.pere[z] = y;
Pile.ajouter (z, p);
continue boucle;
}
Pile.supprimer (p);
}
}
}
Commentaires
Complexit en O(n +m).
On visite encore tous les sommets accessibles depuis la racine, et seulement ceux-ci.
La version non rcursive nest pas optimise, car on parcourt plusieurs fois la liste des
successeurs : il faudrait empiler le rang du successeur visit en mme temps quon lempile,
et incrmenter ce rang au moment o on le dpile.
6.7.2 Analyse ne du parcours en profondeur
On propose ici une version plus labore du parcours en profondeur, quon note DFS, pour
Depth First Search, dans cette section.
Nouvelle version de DFS(G) Quelques notations :
WHITE= sommet non trait, GREY= en cours, BLACK= ni
u V [G], d[u] = date de dbut et f[u] = date de n
DFS(G)
for each vertex u V [G] do
text color(u) WHITE
p(u) NIL
endfor
time 0
for each vertex u V [G] do
if color(u) = WHITE then
DFS-Visit(u)
108
endfor
DFS-Visit(u)
color(u) GRAY //u vient dtre dcouvert
d(u) time time + 1
for each v Adj[u] do
if color(v) = WHITE then
p(v) u
DFS-Visit(v)
endfor
color(u) BLACK //u est termin
f(u) time time + 1
Le cot de DFS(G) est bien enO(n +m) = O(|V | + |E|)
Proprits de DFS
On obtient une fort darbres.
Structure parenthse :
Proposition 6. Pour toute paire de sommets u et v, on a un et une seule des trois
proprits suivantes :
1. les intervalles [d(u), f(u)] et [d(v), f(v)] sont disjoints,
2. lintervalle [d(u), f(u)] est inclus dans lintervalle [d(v), f(v)], et u est un descendant
de v dans larbre DFS,
3. lintervalle [d(v), f(v)] est inclus dans lintervalle [d(u), f(u)], et v est un descendant
de u dans larbre DFS.
Consquence : v est un descendant de u dans la fort DFS
d(u) < d(v) < f(v) < f(u)
Chemin blanc :
Proposition 7. Dans une fort DFS(G), v est un descendant de u linstant d(u) o
on dcouvre u, il existe un chemin WHITE de u v.
Classication des artes
4 types dartes sont produits par DFS(G) :
1. Tree : arcs de la fort
2. Back : arcs (u, v) connectant u un de ses anctres v dans la fort (boucles incluses)
3. Forward : arcs (u, v) connectant u un de ses descendants v dans la fort mais ne
faisant pas partie de celle-ci
4. Cross : toutes les autres
Extension de DFS(G) pour classer larc (u, v) la premire fois que larc est explor :
1. v WHITE (u, v) Tree
2. v GRAY (u, v) Back
3. v BLACK (u, v) Forward ou Cross
Pour les graphes non orients, il ny a que des artes Tree et Back
109
6.8 Tri topologique
Dnition
DAG = graphe orient acyclique
Tri topologique dun DAG = numrotation des sommets qui respecte les arcs :
(u, v) arc de G u a un numro plus petit que v
Application des DAG : ordonnancement
Algorithme
Appeler DFS(G), et trier les f(u) en ordre dcroissant pour avoir une numrotation valide
Au moment o un sommet est termin, linsrer en tte dune liste chane ordre topo-
logique des sommets
Caractrisation :
Proposition 8. G DAG DFS(G) ne donne pas darcs de type Back
6.9 Forte connexit
Algorithme
Composante fortement connexe : ensemble maximal U tel que
u, v U, u v et v u
Calcul avec deux parcours DFS :
1. Appeler DFS(G) et garder les dates de n f((u)
2. Construire le graphe invers G
T
: (u, v) E
T
(v, u) E
3. Appeler DFS(G
T
) mais dans la boucle principale considrer les sommets dans lordre
des f(u) dcroissants
4. Chaque arbre de cette fort DFS(G
T
) est une composante fortement connexe
Preuve de correction La preuve est dtaille dans lexercice qui suit.
6.10 Exercices
Exercice 6.10.1. Composantes fortement connexes dun graphe orient
On travaille sur des graphes orients, que lon suppose reprsents par des listes dadjacence :
soit S lensemble des sommets et A lensemble des arcs, on associe chaque sommet u dans S
la liste Adj[u] des lments v tels quil existe un arc de u v.
1 - Parcours en profondeur
Le parcours en profondeur dun graphe G fait usage des constructions suivantes :
A chaque sommet du graphe est associe une couleur : au dbut de lexcution de la
procdure, tous les sommets sont blancs. Lorsquun sommet est rencontr pour la premire
fois, il devient gris. On noircit enn un sommet lorsque lon est en n de traitement, et
que sa liste dadjacence a t compltement examine.
Chaque sommet est galement dat par lalgorithme, et ceci deux fois : pour un sommet
u, d[u] reprsente le moment o le sommet a t rencontr pour la premire fois, et f[u]
indique le moment o lon a ni dexplorer la liste dadjacence de u. On se servira par
consquent dune variable entire temps comme compteur vnementiel pour la datation.
110
La manire dont le graphe est parcouru dterminera aussi une relation de paternit entre
les sommets, et lon notera [v] = u pour dire que u est le pre de v (selon lexploration
qui est faite, cest dire pendant le parcours v a t dcouvert partir de u).
On dnit alors le parcours en profondeur (PP) de la manire suivante :
PP(S,Adj[],temps) :=
pour chaque sommet u de S Initialisation
faire couleur[u] blanc
[u] nil
temps0
pour chaque sommet u de S Exploration
faire si couleur[u]=blanc
alors Visiter_PP(u)
Visiter_PP(u) :=
couleur[u] gris
d[u] temps temps+1
pour chaque v Adj[u]
faire si couleur[v]=blanc
alors [v] u
Visiter_PP(v)
couleur[u] noir
f[u] temps temps+1
Quel est la complexit de PP? Que peut-on dire de d[u], f[u], d[v] et f[v], pour deux sommets
u et v du graphe ?
Montrer que v est un descendant de u si et seulement si linstant d[u], il existe un chemin
blanc de u v.
2 - Composantes fortement connexes
On dnit la relation binaire R des sommets dun graphe orient par : xRy si et seulement
sil existe un chemin orient de x y et un chemin orient de y x.
Montrer que cest une relation dquivalence.
Les classes dquivalence sont appeles composantes fortement connexes du graphe orient.
Ce sont les sous-ensembles maximaux du graphe tels quil existe un chemin allant dun sommet
u un sommet v pour tous sommets u et v de lensemble.
Montrer que lors dun parcours en profondeur, tous les sommets appartenant la mme
composante fortement connexe sont dans le mme arbre en profondeur (issu de lapplication de
PP sur G).
Pour tout sommet u, et pour une excution dun parcours en profondeur, on appelle (u) le
sommet w tel que u w (i.e. il existe un chemin ventuellement nul de u w) et f[w] est
maximal. On appelle (u) laeul de u.
Montrer que (u) est un anctre de u.
Remarque : par consquent, u et (u) sont dans la mme composante fortement connexe,
et plus globalement, deux sommets sont dans la mme composante fortement connexe si et
seulement si ils ont le mme aeul.
3 - On considre lalgorithme suivant :
Excuter le parcours en profondeur de G pour calculer f sur lensemble des sommets.
Calculer le graphe
t
G qui a les mmes sommets que G mais o le sens des arcs est invers.
111
Excuter le parcours en profondeur de
t
G en appelant dans la boucle principale les sommets
par f dcroissant. Les composantes fortement connexes de G (et aussi de
t
G) sont les arbres
ainsi obtenus.
Montrer la correction de lalgorithme prcdent (par exemple en montrant par rcurrence sur
le nombre darbres dj calculs quune composante fortement connexe, et donc lensemble des
sommets de mme aeul selon G, est un arbre). Quelle est sa complexit ?
Correction.
1 - Parcours en profondeur
1.1 - Complexit et relation entre les sommets
Linitialisation se fait en O(|S|). Grce au systme de coloriage, il est vident que lon appelle
la procdure Visiter_PP sur chaque sommet une fois et une seule, soit directement depuis PP,
soit depuis le traitement dun autre sommet. Le traitement dun sommet se fait en O(1) plus
une comparaison pour chaque arc qui part de ce sommet. Donc chaque arc est galement visite
une fois et une seule car elle est visite uniquement depuis son sommet de tte et chaque sommet
nest trait quune fois. La complexit du parcours est donc clairement en O(|S| + |A|).
Soient u et v deux sommets du graphe. On suppose d[u] < d[v], dans le cas contraire il sut
dinverser les notations. On distingue deux cas :
1. v est un descendant de u. On rencontre alors v avant davoir termin u, et on termine de
lexplorer avant galement. Donc
d[u] < d[v] < f[v] < f[u]
2. v nest pas un descendant de u, ce qui signie que lon termine lexploration de u avant de
commencer celle de v. Do :
d[u] < f[u] < d[v] < f[v]
1.2 - Lemme du chemin blanc
Lemme : v est un descendant de u si et seulement si il existe un chemin blanc de u v
linstant d[u]
preuve : Soit v un descendant de u. Il existe donc un chemin de u v emprunt lors de lex-
cution de lalgorithme. Lalgorithme nempruntant que des sommets blancs, tous les sommets de
ce chemin taient blanc linstant d[u]. Il existe donc un chemin blanc de u v linstant d[u].
Supposons la rciproque fausse : si il existe un chemin blanc de u v, v nest pas forcment
descendant de u. Prenons alors v comme le sommet le plus proche de u tel quil existe un chemin
blanc de u v d[u] et tel que v ne soit pas un descendant de u. Prenons w le sommet prcdent v
sur ce chemin. On a donc w descendant de u (ou w = u) ce qui implique f(w) f(u). u est donc
encore blanc linstant d[w] Donc pendant lexcution de w, soit v est blanc quand on considre
larc w v, dans ce cas on le traite ce moment l, et d[w] < d[u] < f[w], soit il est noir ce
moment l et donc d[w] < f[u] < f[w]. Comme il ny a que deux congurations possible pour les
ingalits entre les dbutsns de traitement, on a dans les deux cas d[w] < d[u] < f[u] < f[w].
Autrement dit, v est un descendant de w, et donc aussi de u par transitivit. Do contradiction
avec lhypothse de dpart.
2 - Composantes fortement connexes
2.1 - Relation dquivalence
112
Il est facile de montrer que R est une relation dquivalence. Par convention, un sommet x a
un chemin de longueur nulle vers lui-mme, do xRx. Dautre part si xRy et yRz alors il existe
un chemin de x y et un chemin de y z. En composant les deux on a donc un chemin de x
z. De mme, comme il existe un chemin de z y et un chemin de y x, il existe un chemin de
z x, donc xRz. Enn comme xRy implique quil y a un chemin de x y et un chemin de y
x, on a, par dnition yRx. R est bien une relation dquivalence.
2.2 - Les composantes fortement connexes sont dans le mme arbre
Soit C une classe composante fortement connexe. Prenons u C tel que d[u] = min
xC
(d[x]).
A d[u] tous les sommets de C sont blancs (sauf u qui est gris), donc x C, il existe un chemin
blanc de u x. Donc daprs le lemme du chemin blanc, x est descendant de u. Donc tous les
sommets de C ( part u) sont descendants de u. Donc tous les sommets de C sont dans le mme
arbre de profondeur.
2.3 - Laeul est un anctre
On a donc (u) = w successeur de u et quelque soit v successeur de u, f(v) f(w).
Si d[u] tous les successeurs de u sont blancs, alors on a clairement w = u, car daprs le
lemme du chemin blanc, tous les autre successeurs seront des ls de u. (u) est donc bien un
anctre de u.
Sinon, d[u], w est gris ou noir. Si il est noir : f[w] < d[u] < f[u], ce qui contredit la
dnition de w. Donc w est gris, ce qui implique la relation d[w] < d[u] < f[w], cest dire que
u est un descendant de w, donc (u) est bien un anctre de u.
(u) est donc la fois un successeur et un anctre de u. Ces deux sommets font donc partis
de la mme composante fortement connexe. De manire plus gnral u et v font partie de la
mme CFC si et seulement si (u) = (v).
3 - Algorithme pour les composantes fortement connexe
Voyons de manire informelle ce que fait lalgorithme dcrit. Tout dabord, il fait un parcours
en profondeur classique. Ainsi tout sommet u, il associe linstant f(u) de n dexcution. A la
n de cet algorithme, on a donc plusieurs arbres de profondeurs.
T1
T2 T3
Fig. 6.1 Aprs excution du premier parcours
Tous les sommets dun mme arbre sont donc atteignables depuis la racine. De mme, si
on prend un sous-arbre de lun des arbres de profondeurs, tous les sommets de ce sous-arbre
sont atteignable depuis la racine de ce sous-arbre. Ensuite, on change le sens des arcs G et on
eectue un parcours en profondeur par f dcroissant. On va forcment commencer par la racine
du dernier arbre de profondeur (dans la gure 6.1, il sagit du sommet T
3
). Chaque arbres gnr
par ce second algorithme sera entirement inclus dans un des arbres du premier algorithme. En
eet, supposons quun sommet de T
2
est atteignable depuis T
3
. Cel signie que dans G, il y a
un arc entre un sommet u de T
2
et un sommet v de T
3
, ce qui est impossible, car lexcution
113
du premier algorithme, linstant d(u), v tait blanc, et donc il aurait t visit et donc v aurait
appartenu T
2
. Supposons maintenant quun sommet de T
2
est atteignable depuis T
3
. Alors, ce
sera lors du traitement du sommet de T
2
quon pourra atteindre celui de T
3
. Mais les sommets
tant traits par f dcroissants, le sommet de T
3
aura dj t trait, donc sera noir, et ne sera
donc pas visit. Les nouveaux arbres sont donc inclus dans les anciens comme le montre la gure
6.2.
T1
T2 T3
: C o mp os a nt es f ort e me nt c onn exes
Fig. 6.2 Aprs excution du second parcours
Les arbres gnrs par ce deuxime algorithme, au moins aussi nombreux que ceux gnrs
par le premier algorithme, regroupent un ensemble de sommets qui sont tous atteignables depuis
la racine, et qui peuvent tous atteindre la racine. Ce sont donc eectivement les composantes
fortement connexe de G (et aussi de
t
G). On va le dmontrer plus formellement par rcurrence
sur les arbres de profondeur de
t
G.
Supposons que tous les arbres obtenus jusqu prsent sont des composantes fortement
connexes de G. Notons r la racine du prochain arbre T. Dnissons lensemble C(r) = {v
S | (v) = r}. Il sagit donc de la composante fortement connexe de r.
Montrons que u T u C(r).
( ) : r tant la racine de T, si (u) = r alors r est un successeurs de u et surtout, il nexiste
pas de successeurs v de u tels que f[v] f[r]. Donc u ne peut pas appartenir un arbre cr
avant T, donc u T.
( ) : si u T, supposons (u) ,= r. Alors, soit f((u)) > r soit f((u)) < r.
si f((u)) > r, alors (u) a dj t visit avant le traitement de r. Et comme u et (u)
sont dans la mme CFC, alors par hypothse de rcurrence, ils appartiennent au mme
arbre de profondeur. Donc u , T, absurde.
sinon, on a f((u)) < r, et r descendant de u car u T, ce qui est impossible par dnition
de .
Il ne reste plus qu dmontrer que le premier arbre de profondeur de
t
G est bien une
composante fortement connexe. Notons T ce premier arbre et r sa racine. Tous les sommets de
T peuvent atteindre r dans G par dnition de
t
G, et comme f[v] est le plus grand f, alors
quelque soit u T, (u) = r. Donc tous les sommets de T font partie de la mme CFC.
Maintenant, supposons un sommet v appartenant cette CFC. Alors on a (v) = r donc, il
existe un chemin de v r dans G, donc un chemin de r v dans
t
G. Ce chemin est forcment
114
blanc au dbut de lexcution de lalgorithme, donc v est un ls de r. Ainsi v T.
On a donc dmontr la validit de lalgorithme. Calculons rapidement sa complexit. La
complexit du parcours en profondeur est O(|S| + |A|), linversion des arcs se fait en O(|A|).
Comme G et
t
G ont le mme nombre darcs et de sommets, on a donc :
C(G(S, A)) = O(|S| + |A|) + O(|A|) + O(|S| + |A|)
= O(|S| + |A|)
Exercice 6.10.2. 2-SAT
Le problme 2-SAT est dni de la manire suivante : on se pose la question de la satisabilit
dune formule boolenne en Forme Normale Conjonctive dordre 2 (2-FNC). Une telle formule
est une conjonction de clauses, chaque clause tant elle-mme constitue dune disjonction de
deux littraux. Un littral dans une formule boolenne est une variable ou sa ngation.
Exemple : (x
1
x
2
) (x
1
x
3
) (x
2
x
3
)
est une 2-FNC, satisable en mettant par exemple x
1
vrai et x
2
faux.
1 - Une condition ncessaire
En remarquant que chaque clause peut scrire de deux manires sous forme dune implication
entre deux littraux, reprsenter la formule comme un graphe orient o les sommets sont des
littraux et les arcs des implications.
Donner une condition ncessaire sur le graphe pour que la formule soit satisable.
On va montrer quil sagit dune condition susante.
2 - Montrer quune valuation v qui satisfait la formule F est constante sur une composante
fortement connexe du graphe associ G.
3 - Graphe des composantes fortement connexes
On construit un graphe orient H associ au graphe G de la manire suivante :
Les sommets de H sont les composantes fortement connexes de G.
Il y a un arc de X Y dans H sil existe un arc dun sommet de X vers un sommet de Y
dans G.
Montrer que H est sans circuit.
4 - Tri topologique
Les arcs induisent alors un ordre partiel sur les sommets de H et cet ordre peut-tre complt
en un ordre total. Lalgorithme du tri topologique est dni de la manire suivante : le graphe
est parcouru en profondeur et les sommets classs par f[u] dcroissant en les insrant au fur et
mesure au dbut dune liste chane.
Montrer que lordre total ainsi obtenu tend bien lordre partiel.
Donner la complexit de la construction de H partir de G et du tri topologique.
5 - On dnit la valuation v de la manire suivante : si la variable x est dans la composante X
et x dans la composante Y alors on pose v(x) = faux si X < Y et v(x) = vrai sinon.
Montrer que v est dnie de manire cohrente et conclure. Quelle est la complexit de
2-SAT?
Correction.
1 - Une condition ncessaire
115
On reprsente la clause l l

par deux liaisons :


l

l
l l

Ainsi, lexemple (x
1
x
2
) (x
1
x
3
) (x
2
x
3
) sera reprsent par le graphe :
x1
x3 x2
x1
x2
x3
Une condition ncessaire pour que le graphe soit satisable est :
y et y sont dans deux composantes connexes distinctes
2 - Une valuation satisfaisant la formule est constante
Montrons quune valuation v qui satisfait la formule F est constante sur une composante
fortement connexe du graphe associ G.
Soit v qui satisfait F, et supposons x et y sur la mme composante connexe. Alors il existe
un chemin de x y, i.e. une srie dimplications de x y, et pout tout w de ce chemin, on a
v(x) = v(w). En particulier, v(x) = v(y).
Donc v est constante sur chaque composante connexe.
3 - Graphe des composantes fortement connexes
On construit H de sorte que les sommets de H sont les composantes fortement connexes
de G, et quil existe un arc de X Y dans H sil existe un arc dun sommet de X vers un
sommet de Y dans G.
Montrons que H na pas de circuit.
Par labsurde, sil existe un circuit dans H, alors les composantes fortement connexes
rencontres sur ce circuit ne forment quune seule composante.
En eet, soit X et Y deux de ces composantes. Il existe un chemin de X Y dans H,
donc il existe un chemin de tout sommet de X tout sommet de Y dans G, i.e X et Y
forment mme composante connexe.
Donc H est sans circuit.
3 - Tri topologique
Chaque composante connexe X de G est reprsente par son aeul x. Lordre partiel impose
que si X Y dans H, alors f(x) < f(y). Il sut donc de montrer que pour tous u, v G,
on a :
u v f(u) > f(v)
On se place au moment o on explore larc u v :
si v est blanc : u antcdent de v f(v) < f(u)
si v est noir : f(v) < f(u) car v a dj t visit
si v est gris : u sera noir avant v donc f(u) < f(v), donc on a :
d(v) < d(u) < f(u) < f(v) u descendant de v
Il existe donc un cycle orient entre u et v. Soit X la composante connexe contenant u
116
et Y celle contenant v. Alors il existe un cycle entre X et Y , ce qui est impossible car
H est sans cycle.
Donc lordre total tend bien lordre partiel.
Complexit de la construction de H :
On calcule les composantes fortement connexes de G en O(|S|+|A|)
A chaque u S, on associe (u).
H est dni sur {(u)}, et il faut parcourir tous les adjacents de chaque sommet u de
G en ajoutant dans H :
(u) (v) pout tout u v
Donc H se construit en O(|S|+|A|).
On dnit la valuation v par : si x X et x Y , alors v(x) = faux si X < Y et
v(x) = vrai sinon.
Cette dnition est cohrente :
si X < Y , alors v(x) = faux ( et vrai Y toujours vrai)
si Y < X, alors v(x) = vrai ( et Y vrai toujours vrai)
Ainsi, la complexit de 2 SAT est de lordre de O(|S|+|A|).
6.11 Rfrences bibliographiques
Encore un grand classique ! Voir les livres de Cormen [2], et de West [11] pour encore plus
dalgorithmes.
117
118
Chapitre 7
Tables de hachage
7.1 Recherche en table
On a une table dcrite par deux tableaux de taille xe N, nom et tel, indics en parallle :
nom[i] a pour tlphone tel[i]
Recherche squentielle Pour trouver un nom on parcourt la table
1. Cot au pire n, cot moyen n/2, o n est le nombre dlments courant des deux
tableaux
2. Par contre linsertion dun nouvel lment (avec test de dbordement n < N) cote
O(1)
Recherche dichotomique On maintient le tableau des noms tri
1. Cot au pire en log n|
2. Par contre linsertion dun nouvel lment cote O(n) (il faut pousser les autres)
Gestion dynamique
On veut construire une structure de donnes de taille m pour stocker des cls (des chanes
de caractre en gnral) qui peuvent prendre leurs valeurs dans un univers de grande taille
n
Mais toutes les cls possibles ne seront pas utilises ...
on peut imaginer une fonction de distribution de cette utilisation (qui dpende de
lapplication vise)
Lapplication classique est en compilation. Les utilisateurs dclarent des variables, dont
lidenticateur est une chane de caractres arbitraire. Impossible de prparer une table avec
une case par chane potentielle. Pourtant, il faut pouvoir vrier rapidement si une variable
rencontre a dj t dclare ou non.
7.2 Tables de hachage
Donne
Une table de hachage T comporte m slots T[0], T[1], . . . , T[m1]
Chaque slot peut accueillir un nom, et pourra tre tendu en cas de besoin
En gnral, T nest que partiellement remplie
Problme
Lunivers des noms X est grand, de taille n m
Pour un nom x X, on veut dterminer sil gure dans T, et si oui trouver sa position i
119
Fonction de hachage
Fonction h : X {0, 1, . . . , m1}
1. facile calculer
2. avec une distribution dapparence alatoire
Collision si h(x) = h(y) pour x ,= y (invitable si m < n)
Mthode de construction
1. Interprter les cls comme des entiers :
x = x
l
. . . x
1
x
0
(x) = x
l
B
l
+. . . +x
1
B +x
0
2. Ramener (x) dans lintervalle entier [0, m1] :
soit par division :
h(x) = (x) mod m
soit par multiplication :
h(x) = m{A(x)}|
o 0 < A < 1 est une constante relle bien choisie
o {X} = X X| est la partie fractionnaire de X
Pour la multiplication, Knuth recommande A =

51
2
= 0.618034. Pour m = 1000 et
(x) = 1999, A(x) = 1235.44994... et h(x) = 449.
Gestion des collisions Deux solutions :
Par chanage des lments (table de collision spare ou liste chane)
Par tentatives rptes jusqu trouver une place (adressage ouvert)
7.3 Collisions spares
Table des collisions auxiliaire
Les collisions sont listes dans une table col parallle la table nom
Pour i = h(x), si nom[i] ,= x, la table des collisions donnera une autre entre de la table i
= col[i] o on pourra continuer chercher
La table col est initialise -1, ce qui signie labsence de collision ultrieure.
Insertion
Le premier lment x tel que h(x) = i est rang en position i de la table
Les lments suivants de mme valeur h sont rangs dans une partie rserve de la table,
de lindice m lindice Nmax 1. Il faut donc prvoir de dclarer des tableaux nom, tel,
col de taille Nmax.
Listes chanes
A chaque slot de la table de hachage on gre une liste chane des lments qui ont cette
valeur h
Conceptuellement, cest la mme mthode. En pratique cest beaucoup plus naturel de
faire appel des listes
120
7.4 Adressage ouvert
Mthode
En cas de collision, on part de i = h(x) et on calcule un prochain candidat pour une place
libre dans la table. On rpte lopration jusqu trouver une place libre
Version simple : pour calculer la place suivante :
i (i + 1) mod m
Version labore :
i (i +h

(x)) mod m
o h

est une deuxime fonction de hachage


Contrainte : les valeurs testes
h(x) +k h

(x) mod m pour 0 k m1


doivent raliser une permutation de {0, 1, . . . , m1}.
Par exemple prendre m premier et poser :
h(x) = x mod m
h

(x) = 1 + (x mod (m1))


Analyse
Le taux doccupation est =
n
m
, o n est le nombre de cls prsentes et m le nombre de
places. En adressage ouvert n m, i.e. = 1
On suppose que toute suite dexamen de places successives est quiprobable (hachage
uniforme)
Le nombre moyen dexamen de places successives est au plus :
1. Pour une recherche infructueuse :
1
1
2. Pour une recherche fructueuse :
1

ln
1
1
+
1

Preuve pour une recherche infructueuse


Dans ce cas, tous les examens sauf le dernier tombent sur une place occupe par une cl
qui nest pas la bonne, et le dernier examen tombe sur une place inoccupe
Soit p
i
= Pr{exactement i examens accdent des places occupes}
Pour i > n, p
i
= 0. Donc le nombre moyen cherch est
M = 1 +
+

i=0
ip
i
= 1 +
+

i=1
q
i
o q
i
= Pr{au moins i examens accdent des places occupes}
q
1
=
n
m
, q
2
=
_
n
m
_
_
n1
m1
_
q
i
=
_
n
m
_
_
n1
m1
_
. . .
_
ni+1
mi+1
_

_
n
m
_
i
=
i
M 1 + +
2
+
3
+. . . =
1
1
121
Preuve pour une recherche fructueuse
Une recherche de la cl k eectue les mmes examens que lors de linsertion de k dans la
table
Daprs ce qui prcde, linsertion du i + 1-me lment cote au plus
1
1i/m
=
m
mi
Do la valeur moyenne cherche
M =
1
n
n1

i=0
m
mi
=
m
n
n1

i=0
1
mi
=
1

(H
m
H
mn
)
ln i H
i
=

i
j=1
1
j
ln i + 1
M
1

(ln m+ 1 ln(mn)) =
1

ln
m
mn
+
1

=
1

ln
1
1
+
1

7.5 Rfrences bibliographiques


Ce court chapitre sinspire du Cormen [2].
122
Chapitre 8
Analyse amortie
Dans ce chapitre, on cherche moyenner le cot de n oprations successives : ne pas confondre
avec lanalyse en moyenne dune operation !
8.1 Compteur
Etudions lincrmentation dun compteur k bits :
x = 0, for i = 1 to n do x + +
Exemple : si k = 6
0 0 0 0 0 0
0 0 0 0 0 1
0 0 0 0 1 0
0 0 0 0 1 1
0 0 0 1 0 0
On dnit le cot dune incrmentation comme le nombre de bits qui changent lors de celle
ci. Ce cot nest pas constant pour chaque valeur de x. On remarque que ce cot quivaut au
nombre de 1 successifs droite du compteur plus un (qui correspond la transformation du
premier 0). Ainsi le cot des n implmentations successives est major par nk. Cependant cette
majoration peut tre amliore, en eet on remarque que le bit de poids faible change toutes
les tapes, que le second bit change une fois sur deux... Ainsi on peut majorer le cot des n
oprations par :
n +
n
2
+
n
4
+... 2n
Et ce quelle que soit la valeur de k.
8.1.1 Mthode des acomptes
Le principe est de prpayer pour les oprations que lon va faire par la suite. Chaque fois
quil y a ip dun bit de 0 1, on paye disons 2 euros : un euro pour le ip, lautre en prvision
du futur ip de 1 0. De sorte quon nest jamais dbiteur : quand on ippe en sens inverse, on
ne paye rien, car tout a t prpay. On retrouve donc une majoration en 2n (car il peut y avoir
des oprations prpayes non ralises) pour n oprations.
123
8.1.2 Mthode du potentiel
Notons :
f(i) le potentiel aprs i oprations
c(i) le cot de lopration i
C(i) = c(i) +f(i) f(i 1) le cot moyen
ainsi :
n

i=1
C(i) =
n

i=1
c(i) +f(n) f(0)
Dans notre exemple, f(i) reprsente le nombre de bits de valeur 1 aprs lopration i. Donc :
... 0 1 . . . 1 f(i 1)
... 1 0 . . . 0 f(i) = f(i 1) t(i 1) + 1
o t(i 1) est le nombre de 1 de poids faible successifs avant lopration i. Or comme c(i) =
1 +t(i 1) on retrouve bien C(i) = 2.
8.2 Malloc primaire
Le but est dinsrer n lments dans une table, de manire dynamique.
On insre chaque fois un nouvel lment, directement si la table nest pas pleine. Sinon, on
cre une nouvelle table de taille double, o lon recopie lancienne puis o lon insre. Le cot
correspond alors la taille de lancienne table, augmente de 1.
(Invariant : la table est toujours au moins moiti pleine, donc il arrive que le cot soit lev,
mais on a dans ce cas libr de la place pour les insertions suivantes.)
Le problme se pose alors en ces termes : quel est le cot de n insertions successives ?
8.2.1 Mthode globale
c(i) =
_
1 si i ,= 2
k
+ 1
2
k
+ 1 sinon
Donc on a :
n

i=1
c(n) n +
log
2
(n)

k=0
2
k
3n
8.2.2 Mthode des acomptes
Admettons que jai trois euros en main : un pour payer linsertion, un que je garde dans ma
main pour payer mon transfert, et un que je passe un lment de la premire moiti de la
table, pour prparer son transfert. Par consquent, chaque fois quon double la table, on peut
transfrer les lments gratuitement.
8.2.3 Mthode du potentiel
Le potentiel est en fait un moyen de reprsenter la richesse de la table ; elle est riche quand
elle est pleine. Le potentiel de la table est gal deux fois le nombre dlments moins la taille
124
de la table. Si i ,= 2
k
+ 1 alors C(i) = c(i) +f(i) f(i 1) = 1 + 2 = 3 et si i = 2
k
+ 1 alors la
taille de la table en i 1 est de 2
k
et en i de 2
k+1
alors :
f(i) f(i 1) = (2(2
k
+ 1) 2
k+1
) (2(2
k
) 2
k
) = 2 2
k
on retrouve alors C(i) = c(i) +f(i) f(i 1) = 3
8.3 Insertion ET suppression
On reprend le problme prcdent mais on se propose davoir galement une opration de
suppression dlments dans la table. Les contraintes que lon se donne sont davoir une table
jamais trop vide et davoir un cot amorti constant.
Premire ide : Quand la table est pleine, on double sa taille. Quand elle est moins d moiti
pleine, on rduit sa taille de moiti. Cette proposition nest pas acceptable car on peut osciller
entre 2 tailles intermdiaires et avoir ainsi un cot trop lev.
Solution : Si la table est pleine, on double sa taille. Si elle est remplie au quart seulement,
on la rduit de moiti. On trouve C(i)=3. (On peut faire la mthode du potentiel en prenant le
mme potentiel que prcdemment si la table est au moins moiti pleine et la moiti de taille
de la table moins le nombre dlments sinon.)
8.4 Gestion des partitions
Soient n lments : x
1
, x
2
, ..., x
n
; rpartis en n classes dquivalence : c
1
, c
2
, ..., c
n
. On
cherche eectuer des fusions successives. Il sagit en fait dun problme de graphe o lon
rajoute des artes.
8.4.1 Reprsentation en listes chanes
Chaque classe dquivalence est reprsente par une liste chane o chaque lment pointe
sur le reprsentant de la classe.
Pour raliser lunion de deux classes dont on a les lments x et y, on cherche tout dabord
leur pre (le reprsentant de la classe dquivalence laquelle ils appartiennent), sil dire alors
on concatne la plus petite liste la plus grande et on fait pointer tous les lments de la petite
vers le reprsentant de la plus grande.
Le cot de n unions successives est major par nlog(n), et non pas O(n
2
) comme on pourrait
penser en comptant n oprations de cot O(n) chacune. En eet, le pointeur de chaque lment
change log
2
(n) fois au maximum. Au dbut : un lment appartient une classe dquivalence
de taille 1. Si son pointeur change, cest que cet lment a t uni une classe dquivalence
de taille au moins gale la sienne, et donc quil se retrouve dans une classe dquivalence de
taille au moins 2. Si son pointeur change cest quil a t uni une classe au moins double que
prcdemment. On trouve donc un cot amorti en nlog
2
(n).
8.4.2 Reprsentation en arbres
On peut amliorer le rsultat prcdent en reprsentant les classes dquivalence laide de
forts. Trouver un lment a un cot dau moins la hauteur de larbre, tandis quunir a un cot
en temps constant. Ainsi trouver le pre est plus cher mais le gain sur lopration dunion est
beaucoup plus important, en outre lorsque lon recherche le pre on compresse la fort (tout
125
lment parcouru et mis en feuille de la racine) ce qui permet des recherches ultrieures plus
rapides.
Cet algorithme trs clbre de gestion des partitions est d Tarjan ? Le calcul du cot amorti
est dicile. Retenons quil est en O(n(n)), o (n) est linverse de la fonction dAckermann,
et crot lentement mais inexorablement vers +.
8.5 Rfrences bibliographiques
Ce court chapitre sinspire du Cormen [2].
126
Chapitre 9
NP-Compltude
9.1 P versus NP
On distingue deux types de problmes de dcision :
- ceux qui peuvent tre rsolus en temps polynomial en la taille des donnes (classe P)
- ceux pour lesquels on peut vrier un certicat donnant la solution, en temps polynomial en
la taille des donnes (classe NP)
Bien sr P NP. A dfaut de savoir si cette inclusion est stricte ou non, on considre la
classe des problmes NP-complets, qui sont les problmes les plus diciles de la classe NP : si
on connaissait une solution polynomiale pour lun dentre eux, on en connatrait une pour tout
problme de la classe, et on aurait lgalit P = NP. Le plus dicile est de trouver le premier
problme NP-complet, et cela a t le travail de Cook qui a montr que SAT tait complet
(voir par exemple le livre de Wilf, disponible gratuitement sur le Web, cf. les rfrences). Ici,
on va procder par rduction, pour augmenter la liste des problmes NP-complets. On verra
ci-aprs 3-SAT, CLIQUE, VERTEX-COVER. On mentionne aussi CH, le problme du circuit
hamiltonien (voir feuilles de cours). Enn, on dmontre la NP-compltude de trois problmes de
coloration de graphes : COLOR, 3-COLOR, et 3-COLOR-PLAN.
9.2 3-SAT
Dnition 9 (SAT). Soit F une formule boolenne n variables x
1
, x
2
, ..., x
n
et p clauses C
i
:
F = C
1
C
2
... C
p
o C
i
= x

i
1
x

i
2
... x

i
f
(i)
et x

= x ou x
Existe-t-il une instanciation des variables telle que F soit vraie ?
(C
i
vraie pour tout i)
Avec plusieurs variantes NP-compltes :
SAT-k : SAT avec au plus k occurrences de chaque x
i
3-SAT : SAT o chaque clause a 3 littraux C
i
= x

i
1
x

i
4
x

i
3
3-SAT NAE : "not all equal", les trois variables de chaque clause ne sont pas toutes
la mme valeur
3-SAT OIT : "one in three", exactement une variable est VRAI dans chaque clause
Remarque : 2-SAT peut tre rsolu en temps polynomial
Mthode de rduction dun problme P partir dun problme P

NP-complet :
1. P NP : on vrie en temps polynomial le certicat accompagnant une instance I de P
127
2. P est complet : on rduit partir de P

. On transforme une instance I


1
de P

en une
instance I
2
de P
(a) taille(I
2
) = P(taille(I
1
))
(b) I
1
a une solution I
2
a une solution
Thorme 12. 3-SAT est NP-complet
Preuve. 1. 3-SAT NP
Soit I une instance de 3-SAT
taille(I) = O(n +p)
Certicat : valeur de chaque x
i
Vrication en O(p)
2. 3-SAT est complet
Rduction partir de SAT, premier problme montr NP-complet par Cook.
Soit I
1
une instance de SAT
n variables x
1
, ..., x
n
p clauses C
1
, ..., C
p
de longueurs f(1), ..., f(p)
taille(I
1
) = O(n +

p
i=1
f(i))
C
i
: clause de P dans I
1
1 variable x : soit a
i
et b
i
deux nouvelles variables
x a
i
b
i
x a
i
b
i
x a
i
b
i
x a
i
b
i
2 variables x
1
x
2
: soit c
i
une nouvelle variable
x
1
x
2
c
i
x
1
x
2
c
i
3 variables : aucun changement
k variables, k > 3, C
i
= x
1
x
2
... x
k
soit z
(i)
1
, z
(i)
2
, ..., z
(i)
k3
(k 3) nouvelles variables
x
1
x
2
z
(i)
1
x
3
z
(i)
1
z
(i)
2
...
x
k2
z
(i)
k4
z
(i)
k3
x
k1
z
(i)
k3
x
k
(a) taille(I
2
) linaire en taille(I
1
)
(b) () : si I
1
a une solution cest dire une instanciation des x
i
telle que j C
j
soit
vraie.
Une solution pour I
2
est :
x
i
inchang
a
i
VRAI
b
i
FAUX
c
i
VRAI
y
1
... y
k
soit y
i
le 1
er
littral vrai :
128
z
1
, ..., z
i2
VRAI
z
i1
, ..., z
k3
FAUX
(c) () si I
2
a une solution :
Instanciation des x
i
, a
i
, b
i
, c
i
, z
i
j
VRAI/FAUX
Les x
1
, ..., x
n
marchent pour la formule de dpart.
9.3 Clique
Dnition 10 (CLIQUE). Soit un graphe G = (V, E), et un entier k : 1 k |V |
Existe-t-il une clique de taille k (un sous graphe complet de k sommets) ?
Taille dune instance : |V | + |E| ou |V | (car |E| |V |
2
)
Thorme 13. CLIQUE est NP-complet
Preuve. 1. CLIQUE NP
Certicat : liste des sommets de la clique.
Vrication en temps quadratique (pour chaque paire, larte doit appartenir E).
2. CLIQUE est complet
Rduction partir de 3-SAT
Soit I
1
une instance de 3-SAT avec n variables boolnnes et p clauses de taille 3
Exemple du Cormen : C
1
C
2
C
3
C
1
= x
1
x
2
x
3
C
2
= x
1
x
2
x
3
C
3
= x
1
x
2
x
3
3 sommets pour chaque clause, et une arte entre deux sommets si et seulement si :
(i) ils ne font pas partie de la mme clause
(ii) ils ne sont pas antagonistes (ne reprsentent pas une variable et sa ngation)
x1 x2 x3
_
x1
x2
x3
x2
x3
x1
_
_
I
2
graphe 3p sommets.
taille(I
2
) polynomiale en taille(I
1
).
3-SAT k-Clique : on slectionne un sommet correspondant une variable vraie dans
chaque clause, et on a bien une clique, car deux de ces sommets ne sont pas contradictoires.
k-Clique 3-SAT : si on a une clique de taille k, alors il y a un sommet par clause. On le
129
slectionne pour instancier les variables, et cest cohrent car on ne fait pas ainsi de choix
contradictoire.
9.4 Couverture par les sommets
Dnition 11 (VERTEX-COVER). Soit un graphe G = (V, E), et un entier k : 1 k |V |
Existe-t-il k sommets v
i
1
, ..., v
i
k
tels que e V , e est adjacente lun des v
i
j
?
Thorme 14. VERTEX-COVER est NP-complet
Preuve. 1. VERTEX-COVER NP
Certicat : liste des k sommets
Pour chaque sommet v V : soit v = v
i
j
, soit j / (v, v
i
j
) E
La vrication se fait en n k
2. Le graphe G a une clique de taille K Le complmentaire de G a une Vertex Cover de
taille |V | K.
9.5 Circuit hamiltonien
Dnition 12 (CH). Soit un graphe G = (V, E) Existe-t-il un circuit hamiltonien dasn G, cest
dire un chemin qui visite tous les sommets une fois et une seule et revient son point de
dpart ?
130
Thorme 15. CH est NP-complet
Preuve. 1. CH NP : facile.
2. Rduction depuis 3-SAT (cf. feuilles distribues en cours)
9.6 Coloration de graphes
Le problme gnral :
Dnition 13 (COLOR). Soit G = (V, E) un graphe et K une borne (comprise entre 1 et
|V |). Peut-on colorier les sommets de G avec K couleurs ? Le problme est dassocier chaque
sommet v V un nombre (sa couleur) color(v) compris entre 1 et K, de telle sorte que deux
sommets adjacents ne reoivent pas la mme couleur :
(u, v) E color(u) ,= color(v)
On peut toujours supposer K |V |, ce qui permet de dire que la taille dune instance de
COLOR est O(|V | +|E|), sans se soucier du log K, ou encore O(|V |), puisque |E| est polynomial
en |V |.
Dnition 14 (3-COLOR). Soit G = (V, E) un graphe. Peut-on colorier les sommets de G
avec 3 couleurs ?
Prendre un instant de rexion pour comprendre pourquoi la NP-compltude de COLOR
nentrane pas automatiquement celle de 3-COLOR.
Dnition 15 (3-COLOR-PLAN). Soit G = (V, E) un graphe planaire (on peut le dessiner
sans que les artes ne se coupent). Peut-on colorier les sommets de G avec 3 couleurs ?
Ici, la restriction est sur la structure du graphe, pas sur le nombre de couleurs. Avant de
dmontrer ces thormes, notons quon a vu plusieurs heuristiques gloutonnes pour colorier des
graphes (avec un nombre de couleurs suprieur loptimal) au Paragraphe 4.2.
9.6.1 COLOR
Thorme 16. COLOR est NP-complet
Preuve. a) COLOR est dans NP.
Une instance I de COLOR est une paire (G, k) de taille | V | + | E | + log k. Comme
certicat on peut choisir une liste des couleurs des sommets. On peut vrier en temps linaire
O(| V | + | E |) si pour chaque arte (x, y) de E la condition color(x) ,= color(y) est vraie et si
la somme des couleurs utilises est gale k.
b) Rduction partir de 3-SAT.
On se donne une instance I
1
de 3-SAT avec p clauses C
k
, k = 1, . . . , p, et n variables x
1
, . . . , x
n
.
Comme on a le droit dignorer les instances faciles on peut supposer n 4. A partir de cette
instance on construit un graphe G = (V, E) avec les 3n +p sommets
x
1
, . . . , x
n
, x
1
, . . . , x
n
, y
1
, . . . , y
n
, c
1
, . . . , c
p
et les artes
(x
i
, x
i
) i = 1, . . . , n
131
x
1
x
2
x
3
x
1
x
2
x
3
y
1
y
2
y
3
c
1
c
2
Fig. 9.1 Exemple : Le graphe construit de la formule (x
1
x
2
) (x
1
x
2
x
3
) Pour simplier
limage on a choisi k = 3.
(y
i
, y
j
) i, j = 1, . . . , n, i ,= j
(y
i
, x
j
) i, j = 1, . . . , n, i ,= j
(y
i
, x
j
) i, j = 1, . . . , n, i ,= j
(x
i
, c
k
) x
i
, C
k
(x
i
, c
k
) x
i
, C
k
.
Un exemple pour la construction de ce graphe est donn en gure 9.1. La taille de I
2
est poly-
nomiale en la taille de I
1
comme | V |= O(n +p).
On va prouver que I
1
a une solution ssi G est coloriable avec n + 1 couleurs.
Supposons que I
1
a une solution : il y a une instantiation des variables t.q. C
k
est vraie pout
tout k. On pose
color(x
i
) = i si x
i
est vraie
color(x
i
) = n + 1 si x
i
est fausse
color(x
i
) = i si x
i
est vraie
color(x
i
) = n + 1 si x
i
est fausse
color(y
i
) = i
et pour color(c
k
) on choisit la couleur dune variable qui met la clause C
k
vraie.
Montrons que cette allocation des couleurs ralise une coloration valide du graphe. Le seul pro-
blme pourrait venir des artes entre les x (ou les x) et les clauses. Soit C
p
une clause colorie
i cause dune variable x
i
ou x
i
qui la met vraie, donc qui est aussi colorie i. Mais cette
variable est dans la clause : alors larte entre cette variable et la clause nexiste pas. On a larte
entre la clause et loppos de la variable, mais celle dernire est colore n+1, donc pas de conit.
Supposons maintenant qu il y a un coloriage de G n + 1 couleurs.
132
Lemme 1. Les y
i
forment une clique, donc ont des couleurs direntes. Quitte renumroter les
couleurs, color(y
i
) = i.
Lemme 2. x
i
et x
i
ont pour couleur i ou n + 1 et ce n est pas la mme.
En eet, x
i
et x
i
sont relis entre eux et avec tous les y
j
, j ,= i, on peut en dduire que
color(
x
i
x
i
) = (
i
n + 1
) ou (
n + 1
i
)
Lemme 3. c
k
ne peut pas avoir la couleur n + 1. En eet, n 4, donc il y a un x
i
t.q. x
i
,
C
k
, x
i
, C
k
.
Supposons alors que color(c
i
) = k 1, . . . , n. On pose
x
i
=
_
1 si color(x
i
) = i
0 si color(x
i
) = n + 1
et (forcment)
x
i
=
_
1 si color(x
i
) = i
0 si color(x
i
) = n + 1.
Alors la variable qui donne c
i
sa couleur est dans la clause C
i
(sinon ils sont relies) et met cette
clause vraie, car sa couleur nest pas n +1. Comme cest vrai pour chaque clause C
i
, I
1
a une
solution.
9.6.2 3-COLOR
Thorme 17. 3-COLOR est NP-complet
Remarque 6. Le fait que COLOR est NP-complet ne dit rien. Par exemple, 2-COLOR est
polynomial (voir Paragraphe 4.2).
Preuve. a) Comme COLOR est dans NP, 3-COLOR est dans NP.
b) On fait une rduction partir de 3-SAT en utilisant le gadget de la gure 9.2.
x x
y y
z z
v
v
Fig. 9.2 A gauche le gadget, droite son symbole.
Lemme 8. Le gadget vrie les deux proprits suivantes :
i) Si x = y = z = 0 alors v est colori 0.
ii) Toute autre entre (x, y, z) permet colorier v 1 ou 2.
Preuve. i) Si x = y = z = 0 alors on ne peut que colorier le gadget comme suivant (g. 9.3) :
Avec ce gadget on construit partir dune instance I
1
de 3-SAT avec p clauses C
k
, k =
1, . . . , p et n variables x
i
, i = 1, . . . , n une instance de 3-COLOR comme graphe G avec
1 + 2n + 6p + 1 = O(n +p) sommets (voir g. 9.4).
133
x = 0
y = 0
z = 0
1 \ 2
2 \ 1
0
1 \ 2
2 \ 1
0
Fig. 9.3 Si x = y = z = 0 alors v = 0
. . .
. . . x
1
x
2
x
3
x
1
x
2
x
3
x
n
x
n
D
Z
v
1
v
2 v
p
Fig. 9.4 Le graphe G construit partir de linstance I
1
de 3-SAT. Le gadget k est reli avec
les variables de la clause C
k
de I
1
.
On va prouver que I
1
a une solution ssi G est 3-coloriable.
. On suppose que I
1
a une solution, c. . d. une instantiation qui met toutes les clauses
vraies. On pose color(x
i
) =
_
1 si x
i
vrai
0 sinon
et color(x
i
) =
_
1 si x
i
vrai
0 sinon
. Comme il y a une
variable vrai dans chaque clause, il y a pour chaque gadget une entre qui est non nulle. La
proprit ii) du gadget permet alors davoir v
i
,= 0 i 1, . . . , p. En posant color(D) = 2 et
color(Z) = 0 on obtient un coloriage de G trois couleurs.
. On suppose que G a une coloration trois couleurs. En permutant les couleurs on
peut supposer que color(D) = 2, color(Z) = 0, color(
x
i
x
i
) = (
1
0
) ou (
0
1
). Car color(Z) = 0
la couleur des v
i
doit tre 1 ou 2. La proprit i) permet de conclure que dans chaque clause
il y a une variable vraie. Par consquence, linstantiation x
i
=
_
1 si color(x
i
) = 1
0 si color(x
i
) = 0
, x
i
=
_
1 si color(x
i
) = 1
0 si color(x
i
) = 0
donne une instantiation des x
i
qui met toutes les clauses vraies.
9.6.3 3-COLOR-PLAN
Thorme 18. 3-COLOR-PLAN est NP-complet
134
Preuve. a) Comme 3-COLOR est dans NP, 3-COLOR-PLAN est dans NP.
b) On fait une rduction partir de 3-COLOR en utilisant le gadget de la gure 9.5, appel W.
b
* * *
a
* * *
a

* * *
b

Fig. 9.5 Le gadget W avec 13 sommets


Lemme 9. Le gadget W vrit les deux proprits suivantes :
i) Pour tout 3-coloriage de W les sommets a et a

ainsi que b et b

ont la mme couleur.


ii) Si (a, a

) et (b, b

) ont la mme couleur donne, on peut completer ce coloriage en un 3-


coloriage de W.
Preuve. ii) Si on donne par exemple a = a

= 0, b = b

= 1, on peut completer le coloriage


comme en gure 9.6. Si on donne a = a

= 0, b = b

= 0, on peut completer le coloriage comme


1
2 0 2
0
1 2 1
0
2 0 2
1
Fig. 9.6 3-coloriage de W avec a = a

= 0, b = b

= 1
dans la gure 9.7. Les autres cas sont symtriques.
Soit maintenant I
1
une instance de 3-COLOR, c. . d. un graphe G. A partir de I
1
on
construit une instance I
2
de 3-COLOR-PLAN comme graphe G en remplaant les artes qui se
croissent par W (voir g. 9.8). Prcisment, une arte (u, v) qui croise (u

, v

) est remplace par


larte (u, a) suivie du gadget W, avec v = a

: on met une arte entre u et lextrmit gauche


135
0
1 2 2
0
1 0 1
0
2 2 1
0
Fig. 9.7 3-coloriage de W avec a = a

= 0, b = b

= 0
a
a
a
a
b
b
b
b
W W W
W
W
W W
G
G
G

Fig. 9.8 On transforme le graphe G en un graphe planaire en remplaant les artes qui se
croissent par le gadget W
du gadget, et on confond v et lextrmit droite du gadget. De mme pour (u

, v

) : il y a une
arte entre u

et lextrmit nord b du gadget, mais v

= b

. De cette faon, comme a et a

ont
la mme couleur, u et v en ont une dirente. Enn, quand il y a plusieurs artes, on place
plusieurs gadgets en srie, en confondant lextrmit droite dun gadget avec lextrmit gauche
du gadget suivant.
G est 3-coloriable ssi G

est 3-coloriable.
Si G est 3-coloriable, la proposition i) donne la solution.
Si G

est 3-coloriable, la proposition ii) donne la solution.


136
9.7 Exercices
Exercice 9.7.1. Complexit de SUBSET-SUM
Montrer que le problme suivant SUBSET-SUM est NP-complet.
SUBSET-SUM
Entre : un ensemble ni S dentiers positifs et un entier objectif t.
Question : existe-t-il un sous-ensemble S

S tel que

xS
x = t ?
Indication : vous pouvez par exemple eectuer une rduction partir de 3-SAT. A partir dun
ensemble de clauses C
0
, ..., C
m1
sur les variables x
0
, ..., x
n1
, considrer S lensemble des entiers
v
i
= 10
m+i
+

m1
j=0
b
ij
10
j
et v

i
= 10
m+i
+

m1
j=0
b

ij
10
j
, 0 i n 1, o b
ij
(resp. b

ij
) vaut
1 si le littral x
i
(resp. x
i
) apparat dans C
j
et 0 sinon, et des entiers s
j
= 10
j
et s

j
= 2.10
j
,
0 j m 1. Trouver alors un entier objectif t tel quil existe un sous-ensemble S

S de
somme t si et seulement si lensemble initial de clauses est satisable. Conclure. Quels autres
entiers auraient aussi march ?
Correction.
SUBSET-SUM est videmment NP.
Pour montrer quil est NP-complet nous allons suivre lindication et eectuer une rduction
partir de 3-SAT.
Pour ce faire nous allons commencer en transformant les donnes de 3-SAT en chire.
Soit C
0
, . . . , C
m1
les clauses et x
0
, . . . , x
n1
les variables de 3-SAT. On construit v
i
et v

i
de
la manire suivante :
v
i
= 10
m+i
+

m1
j=0
(b
ij
10
j
) et v

i
= 10
m+i
+

m1
j=0
(b

ij
10
j
), 1 i n 1 avec
b
ij
=
_
0 si x
i
apparat dans C
j
1 sinon
et b

ij
=
_
0 si x
i
apparat dans C
j
1 sinon
Pour mieux comprendre ce quon fait, on peut imaginer quon cre des (m+n)-upplets dont
les n premires cases il ny que des zros sauf un endroit i qui permet de savoir de quelle
variable on parle, que ce soit x
i
ou x
i
, et les m-suivant permettent de savoir si la variable est
dans les clauses correspondantes.
Dsormais on va sommer certains v
i
et certains v

i
, en fait on somme n entier, une par littral,
T =

n1
j=0
(w
i
) o w
i
vaut soit x
i
soit x
i
. T est un nombre qui commence par n "1" et est suivit
de m chires compris entre 0 et 3 (comme on est parti de 3-SAT il y a au plus 3 variables par
clause et ces m chires correspondres exactment au nombre de littral qui met cet clause vrai).
Si on part dune solution du problme 3-SAT, et quon prend v
i
si x
i
est vrai et v

i
si x
i
est faux,
on remarque que cest m chires sont compris entre 1 et 3.
A partir de l on se demande comment faire la dirence entre les sous-ensembles donnant
un somme qui contient un "0" de ceux donnant une somme sans "0" qui sont exactment les
sous-ensembles correspondant un certicat du problme 3-SAT par la bijection vident v
i
S
x
i
est vrai.
Cest cela que servent les s
j
= 10
j
et s

j = 2.10
j
. En prenant t = 1 . . . 14 . . . 4 et en ne
rchissant que sur les m chires de droite de T on voit que :
- partir de 3 on peut avoir 4,3 + 1
- partir de 2 on peut avoir 4,2 + 2
137
- partir de 1 on peut avoir 4,1 + 1 + 2
- partir de 0 on ne peut avoir 4.
(Cette rection est la mme qui si on considre les nombres comme des n+m-upplets)
Le problme 3-SAT est donc rduit en SUBSET-SUM avec S = {v
i
|1 i n 1} {v

i
|1
i n 1} {s
j
|1 j m1} {s
j
|1 j m1} et t = 1 . . . 14 . . . 4
On a ainsi, que si on trouve une solution du problme 3-SAT, on a une solution du problme
SUBSET-SUM en prenant la bijection precdente, et en completant avec les s
j
= 10
j
et s

j =
2.10
j
. Rciproquement, si on trouve un sous-ensemble S de S tels que si

xS
(x) = t =
1 . . . 14 . . . 4, en prenant

S = S ({v
i
|1 i n 1} {v

i
|1 i n 1}) on a ncessairement
T =

xS
(x) qui est nombre commencant par n "1" et suivit de m chire compris entre 1 et
3 (ni 0 car sans les "s" on perd au plus 3 car 4 ne sont plus car en sans les "s", on atteind au
mieux 3), ce qui montre que comme les aucun "0" napparrait, les instances de 3-SAT peuvent
toutes tres mises vrai, trouv laide de la bijection cite plus haut, donc partir du certicat
de ce problme SUBSET-SUM on retrouve un certicat du problme 3-SAT de dpart.
La rduction prcdente est polynomiale car on passe de n variables et m clauses 2n+2m
entiers de m chires, SUBSET-SUM est donc NP-complet.
Remarques : - On peut faire le mme travail dans toutes les autres bases qui nintroduisent
pas de problmes dues aux phnomnes de retenue.
-On peut aussi remplacer les "4" dans t par nimporte quel autre chire suprieur 4, condition
de rajouter des "s" en nombre susant. -On peut aussi faire des s
i
= 10
m+i
et sans changer t,
a remplace les variables dont pour lesquels peut choisir nimporte que boolen.
Exercice 9.7.2. Variantes de 3-SAT
Montrer la NP-compltude des deux variantes de 3-SAT suivantes :
1. 3-SAT NAE (not all equal), o lon impose que les trois littraux de chaque clause ne
soient pas toutes la mme valeur ;
2. 3-SAT OIT (one in three), o lon impose quexactement un littral soit vrai dans
chaque clause.
Correction.
1. 3-SAT NAE
Evidemment 3-SAT NAE est NP.
Pour montrer quil est NP-complet, et contrairement toute attente, nous allons eectuer une
reduction partir de 3-SAT de la manire suivante :
Pour chaque clause, a b c du problme 3-SAT, on cr les instances a b x et c x f
o f est global (ie f est la mme pour chaque clause cre ainsi)
Sil existe une instanciation des variables qui met toutes les clauses vrai, il en existe aussi
une pour sa rduction, pour cela, il sut de prendre x = a b, avec les notations ci-dessus, de
plus si a et b sont vrai, x sera faux, et donc pour la seconde clause sera mis a vrai par x, on
ni en prenant f toujours faux, on a donc une bonne instanciation pour 3-SAT NAE.
Rciproquement, si on a un bonne instanciation du problme 3-SAT NAE (rduction du
problme 3-SAT) il existe un bonne instanciation pour le problme 3-SAT dorigine. En eet si
f est faux soit c est vrai et donc la clause a b c est vrai, soit c est faux donc x est
vrai, x est donc faux, do soit a soit b est vrai et donc la clause a b c est vrai, par
138
contre si f est vrai, on prend toutes les variables du problme NAE et on prend leur ngation.
Cette instanciation, met toujours NAE vrai, car comme not all equal une variable fausse au
moins par clause qui est vrai, et on recommence comme ci-dessus.
Ce qui prcde montre que tout problme 3-SAT peut se rduire polynomialement (on mul-
tiplie le nombre de clause par deux, et on rajoute une variable plus une par clauses de dpart)
en un problme 3-SAT NAE quivalent, 3-SAT NAE est donc NP-complet.
2. 3-SAT OIT
On fait comme le cas prcdent, sauf qu partir de a b c on cr les trois clauses a x y,
b x x

et c y y

Pour commencer on va montrer que sil existe une bonne instanciation pour le problme 3-SAT
de dpart, il en existe une pour sa rduction 3-SAT OIT.
Cest assez simple montrer une fois quon connait la transformation, par contre elle est un
peu longue trouver. En eet, pour chaque clause de a b c 3-SAT , si a est vrai on met
les variables x et y (avec les notations prcdentes) faux, et on donne la valeur de b x

et
celle de c y

(a, b et c restent inchanges dun problme lautre) ; et si a est faux, alors soit
b, soit c est vrai. Comme la construction est symtrique, on supposera que b est vrai, x et
x

sont donc mis faux, donc y doit tre mis vrai, et y

faux. On a alors exactement une


variable vrai dans les trois instances, a se passe comme a dans chaque instance, et vu quon
ne touche aucun des variables directment associes celle du problme 3-SAT, il ny a pas de
problme.
Dans lautre sens, on va montrer que si on a une instanciation qui permet de rpondre oui au
problme 3-SAT OIT obtenue partir dun problme 3-SAT par la contruction explicite plus
haut alors on en a un pour ce problme 3-SAT. En eet on ne peut avoir aucune clause a b c
faux car cela signie que a, b et c sont faux, ce qui signie que dans les clauses du 3-SAT OIT
quivalentes on a x et x

faux cause de b (dans la deuxime clause), et de mme, on a y et


y

faux cause de c (dans la troisime clause), ce qui donne que la premire clause est fausse,
il y a donc contradiction.
On a donc quivalence entre entre les deux problmes. Il y a un certicat pour un problme
3-SAT si et seulement il y en a une pour sa rduction vue prcdement, en un problme 3-SAT
OIT. De plus la rduction est polynomiale (on multiplie le nombre de clause par trois, et on
rajoute six variables par clauses de dpart).
Ce qui prcde montre que tout problme 3-SAT peut se rduire polynomialement en un pro-
blme 3-SAT OIT quivalent, 3-SAT OIT est donc un problme NP-complet.
Remarque : une fois quon montr que 3-SAT OIT est NP-complet, le problme 1 deviens
plus facile, car on dmontre que SUBSET-SUM est NP-complet en faisant la mme construc-
tion, sans les s
i
et s

i
, et en prenat t=1. . . 11 . . . 1
Exercice 9.7.3. SAT-n
On appelle SAT-n le problme SAT restreint aux formules qui nont pas plus de n occurences
de la mme variable.
1 - Montrer que SAT-3 est au moins aussi dur que SAT. En dduire que pour tout n 3, SAT-n
est NP-complet.
139
2 - Soit x une variable apparaissant dans une formule F de SAT-2. Trouver une formule quiva-
lente F et dans laquelle la variable x napparaisse plus. En dduire un algorithme polynomial
pour SAT-2.
Correction.
1. SAT-3
SAT-3 est trivialement NP.
Pour montrer quil est NP-complet, on dun problme de SAT et pour chaque littral x
i
ap-
paraissant k fois avec k avec k > 3 , on applique lalgorithme suivant :
on remplace les occurences de x
i
par k nouveaux littraux y
i
1
, . . . , y
i
k
, et on rajoute les clauses
y
i
1
y
i
2
, . . . , y
i
k1
y
i
k
et y
i
k
y
i
1
.
Les nouveaux littraux apparaissent alors 3 fois chacun (une fois la place de x
i
, et deux
fois dans les nouvelles clauses). De plus les nouvelles clauses entrainent que les y
i
j
prennent tous
la mme valeur : si y
i
j
est vrai, alors y
i
j1
egalement, et inversement, si y
i
j
est faux, alors y
i
j+1
doit ltre aussi (en toute rigueur on devrait rajouter des modulos k), et comme les clauses sont
cycliques, on obtient que tous ces littraux ont la mme valeur.
Enn, si n est le nombre de littraux, et m le nombre de clauses, le nouveau problme obtenu
comporte au plus nm littraux et (m+nm) clauses, donc une instance de SAT se rduit polyno-
mialement en une instance SAT-3 quivalente, et comme SAT-3 est NP, SAT-3 est NP-complet.
Et comme pour tout n 3, SAT-3 est un cas particulier de SAT-n, SAT-n est NP-complet.
2. SAT-2
Soit x une variable dun systme de clauses F de SAT-2, on transforme F selon les cas de
sorte que le systme obtenue soit satisable si et seulement si le systme initial ltait :
- si x (ou x) napparait quune seule fois, on supprime la clause dans laquelle il apparait, car
on est libre de mettre x (ou x), donc toute la clause vrai.
- si x (ou bien x) apparait 2 fois dans une mme clause, ou dans 2 clauses distinctes, on
supprime la ou les clauses, pour la mme raison.
- si x et x apparaissent dans la mme clause, on supprime la clause car elle est toujours
vrai.
- si x et x apparaissent dans 2 clauses distinctes, x C
1
et x C
2
, alors le systme de clause
est satisable si et seulement si au moins des deux clause C
1
ou C
2
peut tre mis vrai en mme
temps que les autres clause (pour lautre on choisit x pour complter), ainsi :
si C
1
= C
2
= alors le systme nest pas satisable.
sinon on remplace les 2 clauses par la nouvelle clause C
1
C
2
.
On a ainsi dni un algorithme en n tapes (o n est le nombre de littraux), pour lequel
on dcide chaque tape de la valeur dun littral avec une complexit m (o m est le nombre
de clauses) : on peut donc rsoudre SAT-2 en _(nm).
140
Exercice 9.7.4. De la NP-compltude
Montrer que les problmes suivants sont NP-complets :
Chevaliers de la table ronde Etant donns n chevaliers, et connaissant toutes les paires de
froces ennemis parmi eux, est-il possible de les placer autour dune table circulaire de
telle sorte quaucune paire de froces ennemis ne soit cte cte ?
Deux cliques Etant donn un graphe G = (V, E), et un entier K > 0, existe-t-il deux cliques
disjointes de taille K dans G? On rappelle quune clique est un sous-ensemble de sommets
tous adjacents deux deux.
Chemin avec paires interdites Soient G = (V, E) un graphe orient (on distingue larc (u,v)
de larc (v,u)), deux sommets de ce graphe s, t V et une liste C = {(a
1
, b
1
), . . . , (a
n
, b
n
)}
de paires de sommets de G. Existe-t-il un chemin orient de s vers t dans G qui contient
au plus un sommet de chaque paire de la liste C ?
Indication : faire une rduction partir de 3-SAT.
Vertex Cover avec degr pair Soient G = (V, E) un graphe dont tous les sommets sont de
degr pair, et k 1 un entier. Existe-t-il un ensemble de sommets de G couvrant toutes
les artes et de taille infrieure ou gale k ?
2-Partition avec mme cardinal Soient n = 2p un entier pair, et n entiers strictement po-
sitifs a
1
, a
2
, . . . , a
n
. Existe-t-il une partition de {1, 2, . . . n} en deux ensembles I et I

de
mme cardinal p et tels que

iI
a
i
=

iI
a
i
?
Clique pour graphe rgulier Soient G = (V, E) un graphe dont tous les sommets sont de
mme degr, et k 1 un entier. Existe-t-il une clique de taille suprieure ou gale k ?
Roue Etant donns un graphe G = (V, E) et un entier K 3, dterminer si G contient une roue
de taille K, i.e. un ensemble de K + 1 sommets w, v
1
, v
2
, . . . , v
K
tels que (v
i
, v
i+1
) E
pour 1 i < K, (v
K
, v
1
) E et (v
i
, w) E pour 1 i K (w est le centre de la roue).
Dominateur Etant donns un graphe G = (V, E) et un entier K 3, dterminer si G contient
un dominateur de cardinal K, i.e. un sous-ensemble D V de cardinal K tel que pour
tout sommet u V \ D, il existe u D avec (u, v) E
2-Partition-Approx Etant donns n entiers a
1
, a
2
, . . . , a
n
, peut-on trouver un sous-ensemble
I [1..n] tel que |

iI
a
i

i / I
a
i
| 1
Charpentier Etant donnes n baguettes rigides de longueur entires a
1
, a
2
, . . . , a
n
, pouvant
tre relies dans cet ordre bout--bout par des charnires, et tant donn un entier k,
peut-on assembler toutes les baguettes de manire quen repliant la chane obtenue la
longueur totale ne dpasse pas k
Correction.
Chevaliers de la table ronde
NP : trivial.
Instance I1 de dpart : (V,E) de Circuit Hamiltonien.
Instance I2 cre : On cre un chevalier pour chaque sommet de V. Deux chevaliers sont
froces ennemis ssi il ny a pas darte de E entre les deux sommets de V desquels ils proviennent.
Equivalence : Si on a un Circuit ralisable dans I1, alors on place les chevaliers autour de
la table de la faon suivante : un chevalier est voisin dun autre ssi le sommet reprsentant du
premier est reli au sommet reprsentant du second dans le circuit.
Rciproquement, si on peut runir les chevaliers autour de la table, alors on peut faire un
Circuit en prenant pour artes les artes entre les reprsentants des chevaliers de toutes les paires
de chevaliers voisins.
141
Deux cliques
NP : trivial.
Instance I1 de dpart : (G,k) de Clique.
Instance I2 cre : (G
D
G, k)
Equivalence : Si G a une clique de taille k, alors il y en a une dans G
D
G
Rciproquement, si G
D
G a une clique de taille k, alors elle est forcment dans lun des
deux graphes G car il ny a aucune arte entre eux donc G a une clique de taille k.
Chemin avec paires interdites
NP : trivial.
Instance I1 de dpart : C
1
... C
m
avec C
k
= (l
1k
l
2k
l
3k
) de 3-SAT.
Instance I2 cre : (V,E,P) avec : V = {l
ij
|(i, j) [1; 3] [1; m]} {S, T}. E = {arcs entre S
et tous les littraux de C
1
, arcs entre tous les littraux de C
m
et T, arcs entre tous les littraux
de C
i1
et C
i
pour i [2 ;m]}. P = {Toutes les paires de sommets avec des tiquettes x
i
et x
i
pour i [1 ;n]}.
Equivalence : Sil existe une solution I1, on prend un chemin qui passe par un littral valant
1 dans chaque clause. Il ne contient pas de paire interdite car x
i
et x
i
ne peuvent prendre la
mme valeur en mme temps.
Rciproquement, si on a un chemin ne contenant pas de paire interdite dans I2, on donne la
valeur 1 chaque litral tiquetant les sommets du chemin, et une valeur quelconque aux autres.
Cest une assignation des variables qui satisfait lensemble initial de clauses.
Vertex Cover avec degr pair
NP : trivial.
Instance I1 de dpart : (G,k) de Vertex Cover.
Instance I2 cre : On peut dj remarquer quil y a un nombre pair de sommets de degr
impair dans G car

deg(v) = 2|E|. On construit une instance (G2, k+2) en crant trois
nouveaux sommets x, y et z. Ensuite on relie x chaque sommet de G de degr impair, ainsi
qu y et z, et on relie y et z (on a ainsi form un triangle xyz)
Equivalence : Sil existe une couverture C dans V de cardinal plus petit que k pour G, alors
il existe une couverture de cardinal plus petit que k+2 (par exemple C {x,y} pour G2.
Rciproquement, sil existe une couverture C2 de cardinal plus petit que k+2 pour G2, alors
C2 contient forcment au moins deux sommets dans {x,y,z} car cest un triangle qui nest reli
au reste du graphe que grce x. Donc C = C2 \{x,y,z} est une couverture de G de cardinal
plus petit que k.
2-partition avec mme cardinal
NP : trivial.
Instance I1 de dpart : a
1
, ...a
n
de 2-partition.
Instance I2 cre : (a
1
+ 1, ...a
n
+ 1, 1, ...1) de cardinal 2n.
Equivalence : Si

iI
a
i
=

i[1,n]\I
a
i
alors

iI
(a
i
+1)+(n|I|) =

i[1,n]\I
(a
i
+1)+|I|.
Rciproquement, une solution est de la forme

iI
(a
i
+1)+(n|I|) =

i[1,n]\I
(a
i
+1)+|I|.
En eet il faut avoir n termes droite et gauche donc il faut rajouter un (n |I|) gauche,
et |I| n sinon au naurait jamais lgalit, car tous les a
i
sont positifs. Ainsi on a bien

iI
a
i
=

i[1,n]\I
a
i
Clique pour graphe rgulier
NP : trivial.
Instance I1 de dpart : ((V,E),k) de Clique.
142
Instance I2 cre : Notons (G) le maximum des degrs des sommets de V. On fait (G)
copies de G, pour chaque sommet v de V on cre (G) deg(v) nouveaux sommets quon relie
chacune des (G) copies de ce sommet. On a ainsi un graphe rgulier o chaque sommet un
degr gal (G).
Equivalence : La construction ne cre pas de nouvelles cliques ni nagandit des cliques exis-
tantes pour G, donc cest vident.
2-partition approx
NP : trivial.
Instance I1 de dpart : a
1
, ...a
n
de 2-partition.
Instance I2 cre : (1664a
1
, ...1664a
n
).
Equivalence : Sil existe I avec

iI
a
i
=

i[1,n]\I
a
i
, alors |

iI
a
i

i[1,n]\I
a
i
| = 0 1
Rciproquement, sil existe I avec |

iI
1664a
i

i[1,n]\I
1664a
i
| 1, alors on a |

iI
a
i

i[1,n]\I
a
i
| 1/1664. Or on travaille dans les entiers, ainsi on aboutit

iI
a
i
=

i[1,n]\I
a
i
.
9.8 Rfrences bibliographiques
Ce chapitre sinspire du clbre livre de Garey et Johnson [5]. Le lecteur qui cherche une
introduction claire aux machines de Turing, et une preuve concise du thorme de Cook, trouvera
son bonheur avec le livre de Wilf [12], dont la premire dition est mise par lauteur la libre
disposition de tous sur le Web : http://www.cis.upenn.edu/~wilf/.
143
144
Chapitre 10
Algorithmes dapproximation
10.1 Dnition
On connat un certain nombre de problmes NP-complets :
3-SAT, Clique, Vertex cover
Subset sum n entiers a
1
, . . . , a
n
et un objectif t
existe-t-il I /

iI
a
i
= t
2-Partition n entiers a
1
, . . . , a
n
existe-t-il I/

iI
a
i
=

iI
a
i
Color, Chemin Hamiltonien
En fait, la plupart dentre eux sont des problmes de dcision associs des problmes dopti-
misation. A dfaut de calculer la solution optimale, peut-on lapproximer ?
Dnition 16. Un algorithme de -appproximation est un algorithme polynomial qui renvoie
une solution approche garantie au pire cas un facteur
Exemple : Pour un problme de minimisation, dire que la solution est garantie un facteur
de loptimal scrit :
I instance du problme, ObjAlgo(I) ObjOpt(I)
10.2 Vertex cover
10.2.1 Version classique
Soit G = (V, E) un graphe
On cherche une couverture des artes de taille minimale. Une couverture est un sous-ensemble
des sommets tel que toute arte soit adjacente lun dentre eux.
Glouton :
S
tant quil y a des artes non couvertes
prendre une arte e = (u, v)
faire S S u, v
dtruire les artes adjacentes aux sommets u et v
145
(a) GLOUTON-COVER construit une couverture
(b) GLOUTON-COVER sexcute en temps polynomial
Thorme 19. GLOUTON-COVER est une 2-approximation.
Preuve. Soit A lensemble des artes choisies par glouton.
Le cardinal de la couverture obtenue est 2 |A| : |C
cover
| = 2|A| car les artes de A nont pas de
sommet en commun.
Or |C
opt
| |A| car il faut bien couvrir ces artes indpendantes/
Donc |C
cover
| 2|C
opt
|
Remarque 7. Le facteur 2 peut-il tre atteint ? Oui pour deux sommets isols relis par une
arete.
Peut-on faire = 1, 99 ? Ouvert
On connat = 2
log log |V |
2 log |V |
10.2.2 Version pondre
Chaque sommet a maintenant un poids w
i
Problme : minimiser

iI
w
i
(pour I couverture)
On pose x
i
= 1 si v
i
est pris dans la couverture
x
i
=
_
1 Si v
i
est pris dans la couverture
0 sinon
On veut trouver :
min

x
i
{0,1}
x
i
w
i
sous les contraintes
x
i
+x
j
1 pour toute arte (i, j) E
On trouve la solution du problme linaire sur les rationnels, i.e. on trouve x

i
[0, 1] tels
que

i
[0,1]
x

i
w
i
estminimal
(sous les contraintes prcdentes).
Ensuite on pose x
i
= 1 x

i

1
2
Cest une couverture : on a x
i
+x
j
1 ((i, j) E)
(a) Cest une solution (cest une couverture)
en eet x

i
+x

j
1
Soit x

i

1
2
alors x
i
pris
Soit x

j

1
2
alors x
j
pris
(b) Cest une 2-approximation
2x
i
w
i

(2x

i
)w
i
146
10.3 Voyageur de commerce : TSP
10.3.1 Dnition
Dnition : G = (V, E) graphe complet
c : E N poids sur les artes
borne K > 0
Existe-t-il une tourne (un chemin hamiltonien) de poids K ?
Thorme 20. TSP est NP complet.
Preuve. TSP NP, le certicat est la liste des artes de la tourne.
Compltude : rduction partir de CHEMIN HAMILTONIEN.
Soit une instance I
1
de Chemin-Hamiltonien : graphe G = (V, E) . Existe-t-il un chemin
hamiltonien de G?
On construit une instance I
2
de TSP : on prend G

= (V, E

) complet
On dnit c tel que :
c(e) =
_
1 si e E
0 sinon
On prend K = 0
On a bien une rduction :
Taille polynomiale (trivial)
Solution de I
1
Solution de I
2
(trivial aussi)
10.3.2 Inapproximabilit de TSP :
Dnition : une - approximation est un algorithme polynomial tel que :
I instance du problme, Sol
algo
(I) Opt(I)
Thorme 21. > 0 , il nexiste pas de - approximation sauf si P = NP.
Preuve. Preuve par labsurde :
Supposons quil existe une - approximation, je vais alors pouvoir rsoudre chemin hamiltonien
en temps polynomial.
Soit G = (V, E) instance de chemin hamiltonien
Dans le graphe complt , on construit c tel que :
c(e) =
_
1 si e E
|V | + 1 sinon
On utilise ensuite lalgorithme de - approximation et le cot est infrieur |V | si et
seulement sil existe un chemin hamiltonien (un chemin hamiltonien est un TSP sur les artes
donnes).
10.3.3 2-approximation dans le cas o c vrie lingalit triangulaire
On a un graphe G = (V, E) et un poids c tel que c(u, v) c(u, w)+c(w, v) (c vrie lingalit
triangulaire).
147
Voila un petit exemple (ici c est la distance euclidienne) :
a d
e
b f g
c

h
Principe :
Construire T un arbre de poids minimum de G (un algorithme glouton le fait en temps
polynomial). Ici on trouve larbre avec les artes a-b, b-c, b-h, a-d, d-e, e-f et e-g.
Doubler les artes de T et faire un parcours de ces artes (ex : w = abcbhbadefegeda)
On ne garde que la premire occurrence de chaque lettre pour obtenir une tourne (ex :
abcehdefga)
Thorme 22. c(Tourne) 2 c(opt)
Preuve. c(w) = 2 c(T)
c(Tourne) c(w) cause de lingalit triangulaire
c(T) c(Opt) car une tourne prive dune arte est un arbre
donc c(Tourne) 2 c(opt)
Remarque : Lheuristique de Lin Kernighan fournit de bons rsultats.
10.4 Bin Packing : BP
10.4.1 Dnition
Boites de tailles B
Objets de volume a
1
, . . . , a
n
But : mettre ces objets dans un nombre minimal de boites.
Dnition : n rationnels : a
1
, . . . , a
n
avec 0 < a
i
1
Peut-on les partitionner en K boites B
1
, . . . , B
K
de capacit 1, cest dire tel que :

jB
k
a
j
1
Thorme 23. Bin Packing est NP complet.
Preuve. BP NP (facile) certicat : liste des entiers de chaque boite
Rduction partir de 2-Partition
Soit une instance I
1
de 2P : b
1
, . . . , b
n
On construit une instance I
2
de BP : a
i
=
b
i
S
2
avec S =

n
i=1
a
i
On prend K=2.
Taille polynomiale (trivial)
Solution de I
1
Solution de I
2
(trivial aussi)
Thorme 24. Pour tout > 0 il nexiste pas de
3
2
approximation sauf si P=NP.
148
Preuve. On suppose quil existe une
3
2
approximation pour Bin-Packing. Alors il existerait
un algorithme polynomial pour rsoudre 2-Partition.
On soumet lalgorithme les a
i
dnis prcdemment ; sil existe une 2-Partition, alors lal-
gorithme renvoie au plus 2(
3
2
) = 3 2 botes, donc renvoie 2 botes. Sinon, il renvoie au
moins 3 botes.
On a donc un algorithme polynmial pour rsoudre 2-Partition. Absurde.
10.4.2 Next Fit
Principe
Prendre les objets dans un ordre quelconque
Placer lobjet courant dans la dernire bote utilise sil tient, sinon crer une nouvelle
bote
Variante : First Fit
Prendre les objets dans un ordre quelconque
Placer lobjet courant dans la premire bote utilise o il tient, sinon crer une nouvelle
bote
Approximation
Proposition : Next Fit est une 2-approximation
Preuve :
On pose
A =
n

i=1
a
i
Par construction, la somme des contenus de toute paire de botes conscutives est strictement
suprieure 1. Donc si on a K botes,
K 1 <
K1

i=1
contenu(B
i
) +contenu(B
i+1
)
En outre on a
K1

i=1
contenu(B
i
) +contenu(B
i+1
) 2A
Donc
K 1 < 2A|
Donc
K 2A|
Donc Next Fit utilise au plus 2A| botes. Or loptimal utilise au moins A| botes. Donc Next
Fit est bien une 2 approximation.
Remarque : La borne 2 est stricte.
On considre 4n lments de taille
1
2
,
1
2n
(2n fois). Next Fit utilise 2n botes, alors que
loptimal en utilise n + 1.
149
10.4.3 Dec First Fit
Principe
Trier les a
i
par ordre dcroissant
Placer lobjet courant dans la premire bote utilise o il tient, sinon crer une nouvelle
bote
Approximation
Proposition : K
DFF

3
2
K
Opt
+ 1
Preuve :
On pose
A = {a
i
>
2
3
} B = {
2
3
a
i
>
1
2
} C = {
1
2
a
i
>
1
3
} D = {
2
3
a
i
}
Dans la solution de DFF, sil existe au moins une bote ne contenant que des lments de
D, alors au plus une bote (la dernire) a un taux doccupation infrieur ou gal
2
3
. En eet,
si les lments de D de la dernire bote nont pu tre mis dans les botes prcdentes, cest que
celles-ci sont remplies au
2
3
au moins (do la borne).
Sinon, la solution de DFF est la mme que celle de linstance o on enlve les lments de
D. La solution de DFF pour les lments de A, B et C est optimale. Dans toute solution,
les lments de A sont tout seuls
les lments de B et C sont au plus 2 par botes et on a au plus un lment de B par bote
Or DFF fait la meilleure rpartition des C en les appariant au plus grand B ou C compatible.
Remarque : On peut montrer K
DFF

11
9
K
Opt
+ 4.
10.5 2-Partition
Dnition 17. Soit a
1
. . . a
n
des entiers. Existe-il I tel que

iI
a
i
=

i / I
a
i
?
10.5.1 NP-compltude au sens faible et au sens fort
Quelle est la taille dune instance I de 2-Partition ? On peut la dnir par
n +
n

i=1
loga
i
| n +max
i{1..n}
loga
i
| nlog
n

i=1
a
i
|
Attention : Rsolution de 2-Partition par programmation dynamique On dnit m(i, T) par :
il existe un sous-ensemble I des a
1
. . . a
i
tel que

jI
a
j
= T. On a :
m(i, T) = m(i 1, T) m(i, T a
i
)
On a la solution du problme en m(n,
Psum
2
) avec P
sum
=

n
i=1
a
i
.
La complexit est en O(nS). On a donc un algorithme pseudo-polynmial.
Pour une instance I on dnit Max(I) par (au choix) :
n

i=1
a
i
Max
i{1...n}
a
i

n
i=1
a
i
n
150
Pour un polynme P, on dnit Probleme|
P
en restreignant Probleme ses instances I
telles que Max(I) P(taille(I))
Un problme est NP-complet au sens fort si et seulement si il existe un polynme P tel que
Probleme|
P
reste NP-complet.
Un problme de graphes, sans nombres, est NP-complet au sens fort. Pour les problmes avec
des nombres (dont les problmes de graphes pondrs), il faut faire attention. Ainsi 2-Partition
est NP-complet au sens faible, de mme que Subset-Sum, ou Knapsack : intuitivement, cela veut
dire que le problme nest dicile que si on ne borne pas la taille des donnes dans linstance
examine. Un exemple de problmes avec des nombres qui est NP-complet au sens fort est 3-
Partition, dont le nom est trompeur car il ne ressemble gure 2-Partition : tant donns un
entier B, 3n entiers a
i
, peut-on les partitionner en n triplets, chacun de somme B? On peut
supposer que la somme de tous les a
i
vaut nB (sinon il ny a pas de solution) et quils tous
compris strictement entre B/4 et B/2 (pour quil faille exactement trois lments pour avoir
une somme gale B).
10.5.2 Approximation gloutonnes
Le problme doptimisation associ 2-Partition est le suivant : soit a
1
. . . a
n
des entiers.
Minimiser
max
I{1,2,...,n}
_

iI
a
i
,

i / I
a
i
_
(bien sr le minimum sera toujours au moins P
sum
/2, o P
sum
=

n
i=1
a
i
).
On peut voir le problme prcdent comme un problme dordonnancement deux machines
(processeurs) identiques. Il y a n tches indpendantes, qui peuvent tre excutes sur lune des
deux machines en temps a
i
. Lobjectif est de minimiser le temps total dexcution : cest bien le
problme prcdent. Il y a deux variantes naturelles si on veut le rsoudre avec un algorithme
glouton :
- GLOUTON : prendre les tches dans nimporte quel ordre. Les allouer au processeur le moins
charg.
- GLOUTON-TRI : le mme que prcdemment, mais aprs avoir tri les tches par poids
dcroissant.
Lide de trier est que larrive dune grosse tche la n risque de dsquilibrer toute lexcution.
Par contre, il faut connatre toutes les tches avant de commencer lordonnancement (algorithme
o-line). Le glouton sans tri peut sappliquer un problme on-line, o les tches arrivent
dynamiquement (comme des jobs dutilisateurs excuter sur un serveur bi-pro).
Thorme 25. GLOUTON est une 4/3 approximation, GLOUTON-TRI est une 7/6 approxi-
mation, et ces facteurs dapproximation ne peuvent pas tre amliors.
Preuve. On montre dabord que les bornes sont strictes. Pour GLOUTON, prendre trois
tches de poids 1, 1, et 2, GLOUTON ordonnance en temps 3 alors que loptimal est 2. Pour
GLOUTON-TRI, prendre cinq tches, trois de poids 2 et deux de poids 3. GLOUTON-TRI
ordonnance en temps 7, alors que loptimal est 6.
Pour lapproximation, soit P
sum
=

n
i=1
a
i
. En termes dordonnancement, P
sum
est le temps
squentiel. Soit Opt le temps optimal avec deux machines, alors Opt P
sum
/2. Notons aussi
que a
i
Opt pour toute tche a
i
.
Commenons par GLOUTON. Soient P
1
et P
2
les deux processeurs. Disons que P
1
termine
lexcution, et soit a
j
la dernire tche excute sur cette machine. Soit M
1
le temps dexcution
sur P
1
(la somme des tches qui lui sont alloues), et M
2
le temps dexcution sur P
2
. Comme
P
1
termine, M
1
M
2
. Bien sr M
1
+M
2
= P
sum
.
151
On a suppos que a
j
est la dernire tche de P
1
. Soit M
0
= M
1
a
j
la charge de P
1
avant
que GLOUTON ne lui alloue la tche a
j
. Pourquoi GLOUTON choisit-il P
1
? Parce qu ce
moment, P
2
est plus charg que P
1
: M
0
est infrieur ou gal la charge de P
2
ce moment,
elle-mme infrieure sa charge nale M
2
(noter quon a pu rajouter des tches P
2
aprs avoir
ordonnanc a
j
) : donc M
0
M
2
. Pour rsumer, le temps de GLOUTON est M
1
, avec
M
1
= M
0
+a
j
= 1/2((M
0
+M
0
+a
j
) +a
j
) 1/2((M
0
+M
2
+a
j
) +a
j
) = 1/2(P
sum
+a
j
)
M
1
Opt +a
j
/2 Opt +Opt/2,
do la 3/2-approximation pour GLOUTON.
Pour GLOUTON-TRI on reprend la preuve prcdente mais on va tre plus prcis que la
majoration a
j
Opt. Dabord, si a
j
Opt/3, on obtient juste ce quil faut, M
1
7/6Opt.
Mais si a
j
> Opt/3, alors j 4 : en eet, si a
j
tait la cinquime tche, comme les tches sont
tries il y aurait au moins 5 taches de poids suprieur Opt/3, et dans tout ordonnancement,
y compris loptimal, lune des machines aurait la charge de trois dentre elles, contradiction. On
remarque alors que le temps de GLOUTON-TRI est le mme pour ordonnancer toutes les tches
que pour ordonnancer les j 4 premires. Mais pour tout ensemble dau plus quatre tches,
GLOUTON-TRI est optimal, et M
1
= Opt.
10.5.3 Une (1 + )-approximation
On va montrer que 2-Partition admet un schma dapproximation polynomial PTAS, pour
Polynomial Time Approximation Scheme : pour toute constante = 1 + > 1, il existe une
-approximation, i.e. un algorithme dont la performance est garantie un facteur , et dont le
temps dexcution est polynomial. Attention : polynomial en la taille de linstance de 2-Partition,
mais pas forcment en 1/, cest l toute la subtilit. On verra plus loin un FPTAS, pour Fully
Polynomial Time Approximation Scheme, o le temps est polynomial la fois en la taille de
linstance et en 1/.
Thorme 26. > 0, 2-Partition admet une (1 +)-approximation.
Preuve. On pose :
P
sum
=
n

i=1
a
i
P
max
= max a
i
L = max(
1
2
P
sum
, P
max
)
On a dj vu plus haut que :
Lemme 10. L Opt.
Soit I une instance de 2-partition : a
1
, ..., a
n
. et > 0. On appelle big jobs, les a
i
tels que :
a
i
> L et small jobs ceux tels que : a
i
L. Considrons linstance I

qui regroupe uniquement


les big jobs et
S
L
| jobs de taille L, o S =

a
i
small job
a
i
.
Lemme 11. Opt

(1 + )Opt (ingalit (A)), o Opt est un ordonnancement optimal pour I


et Opt

un ordonnancement optimal pour I

.
152
Preuve. Considrons un ordonnancement optimal Opt pour linstance de dpart I. Soient S
1
la somme des small jobs sur la machine P
1
et S
2
celle des small jobs sur la machine P
2
.
P
1
: oo - ooo -
P
2
: oo - o
o o est un small job et un big job.
Sur chaque machine P
i
, on laisse les gros jobs o ils sont, et on remplace les petits jobs par
_
S
i
L
_
jobs de taille L. On a symboliquement :
P
i
: - - oooo oooo oo
Comme
_
S
1
L
_
+
_
S
2
L
_

_
S
1
+S
2
L
_
=
_
S
L
_
on a ordonnanc au moins autant de jobs de taille L quil y en a dans I

. En faisant ainsi, on
a augment le temps de P
i
dau plus :
_
S
i
L
_
L S
i
L
Le temps dexcution est au moins gal loptimal pour I

, donc :
Opt

Opt +L Opt +.Opt


Comment ordonnancer I

? Combien y a-t-il de jobs dans I

? Quand on a remplac les


petits jobs de I par des jobs de taille L, on na pas augment le temps dexcution total, qui
est born par P
sum
2L. Chaque job de I

a une dure au moins L, donc il y en a au plus


2L
L
=
2

, cest une constante. Au passage, la taille de I

, constante donc, est bien polynomiale en


la taille de linstance de dpart I. Pour odonnancer I

, il sut dessayer toutes les 2


2

possibilits
dordonnancement et de garder la meilleure. Bien sr ceci a un cot non polynomial en 1/, mais
cest une constante en la taille de linstance de dpart.
Retour linstance de dpart I On a dsormais lordonnancement optimal

pour I

. Soit
L

i
la charge de la machine P
i
avec

, quon dcompose en L

i
= B

i
+ S

i
, o B

i
sont les big
jobs et S

i
les small jobs. Par construction de I

, on a lingalit (B) :
S

1
+S

2
= L
_
S
L
_
> S L
On peut alors considrer lordonnancement pour I o les big jobs sont inchangs et o on
fait un glouton avec les small jobs : on les alloue dabord P
1
dans lespace S

1
+ 2 L, puis
quand il ny a plus de place, on les alloue sur P
2
dans lespace S

2
:
Lemme 12. En procdant ainsi, on case tous les small jobs.
Preuve. En eet, on case au moins une quantit S

1
+L de small jobs sur P
1
: chacun dentre
eux prenant moins de L, il faut quil reste moins de L place dans lintervalle allou sur P
1
pour quon soit oblig de passer P
2
. Mais alors il reste au plus S (S

1
+ L) S

2
(daprs
lingalit (B)) allouer P
2
, donc on a bien la place.
Au nal, on a construit ordonnancement pour I en temps polynomial. Son temps dex-
cution excde celui de lordonnancement optimal pour I

dau plus 2L, donc


Opt ordo() Opt

+ 2L (1 + 3).Opt,
la dernire ingalit venant de (A).
153
Ceci conclut la preuve du thorme.
Remarque 8. On peut proposer une preuve plus simple en utilisant la technique des big jobs et
celle du GLOUTON du paragraphe prcdent pour les petits jobs. On ne considre que les bigs
jobs et tous leurs ordonnancements possible. Ils sont en nombre constant, on garde le meilleur.
Le temps de cet ordonnancement Opt
big
est infrieur Opt, lordonnancement optimal pour
linstance de dpart I. On ordonnance alors les small jobs sur les deux machines en GLOUTON,
la suite des big jobs. Soit le temps total de lordonnancement ne change pas, i.e. reste gal
Opt
big
, et alors il est optimal. Soit la machine qui termine termine avec un small job a
j
. Mais
alors sa charge avant cette dernire allocation ne pouvait pas dpasser 1/2P
sum
, sinon on aurait
attribu a
j
lautre machine (mme ide et preuve que pour GLOUTON). Et donc le temps est
au plus 1/2P
sum
+a
j
L +L (1 +)Opt.
10.5.4 FPTAS pour 2-Partition
On va maintenant montrer que 2-Partition admet mme un FPTAS (Fully Polynomial Time
Approximation Scheme), soit que pour toute instance I de 2-Partition et tout > 0, il existe
une (1 +)-approximation qui soit polynomiale la fois en la taille de I et en 1/.
La relation entre PTAS et FPTAS est la mme quentre continuit et uniforme continuit :
on fait changer le de ct. Et bien entendu, admettre un FPTAS tant une proprit plus
forte, (FPTAS PTAS).
Thorme 27. > 0, 2-Partition admet une (1 +)-approximation polynmiale en (1/)
Preuve. On va coder les dirents ordonnancements sous formes de Vector Sets o le premier
(resp. deuxime) lment de chaque vecteur reprsente le temps de travail de la premire (resp.
deuxime) machine :
_
V S
1
= {[a
1
, 0], [0, a
1
]}
V S
k1
V S
k
: [x, y] V S
k1
, [x +a
k
, y] et [x, y +a
k
] V S
k
Entre : les tches a
1
. . . a
n
.
Sortie : le vecteur [x, y] V S
n
qui minimise max(x, y).
Ide : on va numrer tous les ordonnancements possibles, mais en "laguant" au passage
les branches qui ne nous intressent pas.
Soit = 1 +

2n
.
On eectue un quadrillage du plan selon les puissances de , entre 0 et
M
.
M = log

P
sum
| =
_
log P
sum
log
_

__
1 +
2n

_
ln(P
sum
)
_
En eet, si z 1, ln(z) 1
1
z
.
Lide est de ne rajouter les vecteurs que sils tombent dans une case vide.
Comme M est polynmial en
1

et en ln(P
sum
) et que taille(I) ln(P
sum
), il sut de
dmontrer que notre algorithme est bien une (1 +)-approximation.
154
Deux vecteurs [x
1
, y
1
] et [x
2
, y
2
] tombent dans la mme case ssi
_

_
x
1

x
2
x
1
y
1

y
2
y
1
_
V S
#
1
= V S
1
V S
#
k1
V S
#
k
:
[x, y] V S
#
k1
, [x +a
k
, y] V S
#
k
sauf si un vecteur de V S
#
k
est dj dans la mme case. De mme pour [x, y +a
k
].
On ne garde donc quau plus un vecteur par case chaque tape, ce qui donne une complexit
en n M
2
, soit polynmiale en taille(I).
Lemme 13. [x, y] V S
k
, [x
#
, y
#
] V S
#
k
tel que x
#

k
x et y
#

k
y
Preuve. Par rcurrence
k = 1 : trivial
k - 1 k : Soit [x, y] V S
k
,
_

_
x = u +a
k
et y = v
ou
x = u et y = v +a
k
o [u, v] V S
k1
Par hypothse de rcurrence, [u
#
, v
#
] V S
#
k1
o u
#

k1
u et v
#

k1
v
[u
#
+a
k
, v] nest pas ncessairement dans V S
#
k
mais on sait quil y a au moins un lment
de la mme case dans V S
#
k
:
[x
#
, y
#
] V S
#
k
tel que x
#

_
u
#
+a
k
_
et y
#
v
#

_
x
#

k
u +a
k

k
(u +a
k
) =
k
x
y
#
v
#

k
y
et symtriquement pour [u, y +a
k
].
On en dduit donc max(x
#
, y
#
)
n
max(x, y).
Reste montrer
n
(1 +) :

n
=
_
1 +

2n
_
n
Lemme 14. Pour 0 z 1, f(z) =
_
1 +
z
n
_
n
1 2z 0
Preuve. f

(z) =
1
n
n
_
1 +
z
n
_
n1
2.
On en dduit que f est convexe et atteint son minimum en
0
= n
_
n1

2 1
_
. Or f(0) = 1
et f(1) = g(n) =
_
1 +
1
n
_
n
3. On compare une fonction linaire une fonction convexe : si
la relation est vraie aux bornes, elle est vraie partout.
Ceci conclut la dmonstration.
155
10.6 Exercices
Exercice 10.6.1. Approximabilit de SUBSET-SUM
Dans un prcdent TD, on sest intress au problme de dcision SUBSET-SUM consistant
savoir sil existe un sous-ensemble dentiers de S dont la somme vaut exactement t. Le problme
doptimisation qui lui est associ prend aussi en entre un ensemble dentiers strictement positifs
S et un entier t et il consiste trouver un sous-ensemble de S dont la somme est la plus grande
possible sans dpasser t (cette somme qui doit donc approcher le plus possible t sera appele
somme optimale).
On suppose que S = {x
1
, x
2
, . . . , x
n
} et que les ensembles sont manipuls sous forme de listes
tries par ordre croissant. Pour une liste dentiers L et un entier x, on note L+x la liste dentiers
obtenue en ajoutant x chaque entier de L. Pour listes L et L

, on note Fusion(L, L

) la liste
contenant lunion des lments des deux listes.
1 - Premier algorithme
Algorithm:Somme(S, t)
dbut
n |S| ;
L
0
{0} ;
pour i de 1 n faire
L
i
Fusion(L
i1
, L
i1
+x
i
) ;
Supprimer de L
i
tout lment suprieur t ;
retourner le plus grand lment de L
n
n
Quel est la distance entre la valeur retourne par cet algorithme et la somme optimale ? Quelle
est la complexit de cet algorithme dans le cas gnral ? Et si pour un entier k 1 x, on ne
considre que les entres telles que t = O(|S|
k
), quelle est la complexit de cet algorithme ?
2 - Deuxime algorithme
Cet algorithme prend en entre un paramtre en plus, o est un rel vriant 0 < < 1.
Algorithm:Somme-avec-seuillage(S, t)
dbut
n |S| ;
L
0
{0} ;
pour i de 1 n faire
L
i
Fusion(L
i1
, L
i1
+x
i
) ;
L
i
Seuiller(L
i
, /2n) ;
Supprimer de L
i
tout lment suprieur t ;
retourner le plus grand lment de L
n
n
Lopration Seuiller dcrite ci-dessous rduit une liste L =< y
0
, y
1
, . . . , y
m
> (suppose trie
par ordre croissant) avec le seuil :
156
Algorithm:Seuiller(L, )
dbut
m |L| ;
L

< y
0
> ;
dernier y
0
;
pour i de 1 m faire
si y
i
> (1 +)dernier alors
Insrer y
i
la n de L

;
dernier y
i
;
retourner L

n
Evaluer le nombre dlments dans L
i
la n de la boucle. En dduire la complexit totale de
lalgorithme. Pour donner la qualit de lapproximation fournie par cet algorithme, borner le
ratio valeur retourne/somme optimale.
Correction.
On a un ensemble S = {x
1
, . . . , x
n
} dentiers strictement positifs ainsi quun entier t . On cherche
une somme partielle dlments de S maximale et infrieure t. On appellera somme optimale
ce nombre.
1 - Premier Algorithme
Dans le premier algorithme , L
i
reprsente lensemble des sommes partielles des lments de
{x
1
, . . . , x
i
} infrieures t. L
n
reprsente donc lensemble des sommes partielles de S infrieures
t. Par consquent, max(L
n
) renvoie exactement la somme optimale de S. De plus, cet algo-
rithme a test toutes les sommes partielles infrieures t.
On en dduit donc que :
La dirence entre le rsultat trouv et la somme optimale est 0
Dans le pire des cas, on teste toutes les sommes partielles de S soit une complexit de O(
2
n
)
Si t = O( |S|
k
) pour k un entier x, alors |L
i
| = O( |S|
k
). Au pas i de la boucle, la fusion
et la suppression se font en O(|L
i
|). Comme il y a n pas dans la boucle, la complexit
totale est O( |S|
k+1
)
2 - Deuxime Algorithme
Considrons une liste l = {y
0
, . . . , y
m
} dentiers tris par ordre croissant et > 0. Lopration
de seuillage va consister dire : soit y le dernier lment gard de l (on garde y
0
au dpart) si
y
i
> y

(1 + ) alors on va garder y
i
. En gros, on enlve des lments qui sont trop proches
dautres proches dautres lments.
Lalgorithme propos va fonctionner de la mme faon que le prcdent sauf quil va seuiller
chaque pas de la boucle L
i
par rapport /2n. On a alors L
n
= {y
0
, . . . , y
m
}. On va essayer
de majorer m. On sait que :
t y
m
(1 +/2n)
m1
y
0
(1 +/2n)
m1
Do : m ln t/ ln(1 +/2n) (ln t 2n)/(ln 2 ) + 1
m est donc polynomial en ln t et en 1/ ln t polynomial en la taille des donnes lalgorithme
est en O(m * n) donc polynomial en la taille des donnes.
Il faut maintenant vrier quon a bien trouv une (1 +) Approximation en montrant que :
maxL
n
(1 +) Opt(somme optimale)
157
On note P
i
lensemble des sommes partielles de {x
1
, . . . , x
i
} infrieures t.
Invariant : x P
i
, y L
i
, x/(1 +)
i
y x
Par rcurrence :
- i = 0 : OK
- On suppose que cest vrai pour (i-1) et on le montre pour i :
Soit x P
i
P
i
= P
i1
(P
i1
+x
i
)
x = x

+e avec x

P
i1
, e = 0 ou e = x
i
x

P
i1
donc y

, x

/(1 +)
i
y

Si y + e est conserv par le seuillage :


(x

+e)/(1 +)
i
x

/(1 +)
i1
+e y

+e x

+e = x
Si y + e nest pas conserv par le seuillage :
y

L
i
, y

+x
i
y

(1 +)
(y

+e)/(1 +) y

+e x

+e x
(x

/(1 +)
i1
+e)/(1 +) y

(x

+e)/(1 +)
i
y

Cest lencadrement recherch.


Grce linvariant, on obtient : Algo Opt/(1 +/2n)
n
Opt(1 +)
On a donc une 1 + approximation de Subset
s
um polynomial en la
taille des donnees et polynomial en 1/
10.7 Rfrences bibliographiques
Ce chapitre sinspire des livres de Cormen [2], Garey et Johnson [5] et Wilf [12]. Les schmas
dapproximation pour 2-PARTITION sont tirs de [9].
158
Bibliographie
[1] G. Ausiello, P. Crescenzi, G. Gambosi, V. Kann, A. Marchetti-Spaccamela, and M. Protasi.
Complexity and Approximation. Springer Verlag, 1999.
[2] T. H. Cormen, C. E. Leiserson, and R. L. Rivest. Introduction to Algorithms. The MIT
Press, 1990.
[3] M. G. D. Froidevaux and D. Soria. Types de donnes et algorithmes. McGraw-Hill, 1990.
[4] A. Darte and S. Vaudenay. Algorithmique et optimisation : exercices corrigs. Dunod, 2001.
[5] M. R. Garey and D. S. Johnson. Computers and Intractability, a Guide to the Theory of
NP-Completeness. W. H. Freeman and Company, 1979.
[6] D. E. Knuth. The Art of Computer Programming ; volumes 1-3. Addison-Wesley, 1997.
[7] D. C. Kozen. The Design and Analysis of Algorithms. Springer-Verlag, 1992.
[8] G. J. E. Rawlins. Compared to what ? : an introduction to the analysis of algorithms.
Computer Science Press, Inc, 1992.
[9] P. Schuurman and G. Woeginger. Approximation schemes - a tutorial. Research Re-
port Woe-65, CS Department, TU Graz, Austria, 2001. Available at www.diku.dk/
undervisning/2003e/404/ptas_schu_woeg.ps.
[10] V. V. Vazirani. Approximation Algorithms. Springer-Verlag, 2001.
[11] D. B. West. Introduction to Graph Theory. Prentice Hall, 1996.
[12] H. S. Wilf. Algorithms and Complexity. A.K. Peter, 1985. Available at http://www.cis.
upenn.edu/~wilf/.
159