Sda Complet 2011 2012

Structures de données et algorithmes
Pierre Geurts
2011-2012
E-mail : p.geurts@ulg.ac.be
URL : http://www.montefiore.ulg.ac.be/
~geurts/sda.html
Bureau : R 141 (Montefiore)
Téléphone : 04.366.48.15 — 04.366.99.64
1
Contact
Chargé de cours :
I Pierre Geurts, p.geurts@ulg.ac.be, I141 Montefiore, 04/3664815
Assistants :
I Gilles Louppe, g.louppe@ulg.ac.be, GIGA-R (B34,+1), CHU,
04/3662766
I Julien Becker, j.becker@ulg.ac.be, GIGA-R (B34,+1), CHU,
04/3669805
Sites web du cours :
I Cours théorique :
http://www.montefiore.ulg.ac.be/~geurts/sda.html
I Répétitions et projets : http://www.montefiore.ulg.ac.be/
~glouppe/2011-2012/students.info0902.php
2
Objectif du cours
Introduction à l’étude systématique des algorithmes et des structures

de données
Vous fournir une boı̂te à outils contenant :
I Des structures de données permettant d’organiser et d’accéder
efficacement aux données
I Les algorithmes les plus populaires
I Des méthodes génériques pour la modélisation, l’analyse et la
résolution de problèmes algorithmiques
On insistera sur la généralité des algorithmes et structures de
données et on les étudiera de manière formelle
Les projets visent à vous familiariser à la résolution de problèmes
3
Organisation du cours
Cours théoriques :
I Les vendredis de 14h à 16h, S94, Bâtiment B4 (Europe).
I 10-12 cours
Répétitions :
I Certains vendredis de 16h à 18h, S94, Bâtiment B4 (Europe)
I ±5 répétitions (+ debriefing des projets)
Projets :
I Trois projets tout au long de l’année, de difficulté croissante
I Les deux premiers individuels, le troisième en binôme
I En C
Evaluation sur base des projets (30%) et d’un examen écrit (70%).
4
Notes de cours
Transparents disponibles sur la page web du cours avant chaque
cours
Pas de livre de référence obligatoire mais les ouvrages suivants ont
été utilisés pour préparer le cours :
I Introduction to algorithms, Cormen, Leiserson, Rivest, Stein,
MIT press, Third edition, 2009.
I http://mitpress.mit.edu/algorithms/
I Algorithms, Sedgewick and Wayne, Addison Wesley, Fourth edition,
2011.
I http://algs4.cs.princeton.edu/home/
I Data structures and algorithms in Java, Goodrich and Tamassia, Fifth
edition, 2010.
I http://ww0.java4.datastructures.net/
I Algorithms, Dasgupta, Papadimitriou, and Vazirani, McGraw-Hill,
2006.
I http://cseweb.ucsd.edu/users/dasgupta/book/index.html
I http://www.cs.berkeley.edu/~vazirani/algorithms/all.pdf
5
Cours sur le web
Ce cours s’inspire également de plusieurs cours disponibles sur le web :

Antonio Carzaniga, Faculty of Informatics, University of Lugano
I http://www.inf.usi.ch/carzaniga/edu/algo/index.html
Marc Gaetano, Polytechnique, Nice-Sophia Antipolis
I http://users.polytech.unice.fr/~gaetano/asd/
Robert Sedgewick, Princeton University
I http://www.cs.princeton.edu/courses/archive/spr10/
cos226/lectures.html
Charles Leiserson and Erik Demaine, MIT.
I http://ocw.mit.edu/courses/
electrical-engineering-and-computer-science/
6-046j-introduction-to-algorithms-sma-5503-fall-2005/
index.htm
Le cours de 2009-2010 de Bernard Boigelot
6
Contenu du cours
Partie 1: Introduction
Partie 2: Outils d’analyse
Partie 3: Algorithmes de tri
Partie 4: Structures de données élémentaires
Partie 5: Dictionnaires
Partie 6: Résolution de problèmes
Partie 7: Graphes
7
Partie 1
Introduction
Introduction 8
Plan
1. Algorithms + Data structures = Programs (Niklaus Wirth)
2. Introduction à la récursivité
Introduction 9
Algorithmes
Un algorithme est une suite finie et non-ambiguë d’opérations ou

d’instructions permettant de résoudre un problème
Provient du nom du mathématicien persan Al-Khawarizmi (±820),
le père de l’algèbre
Un problème algorithmique est souvent formulé comme la
transformation d’un ensemble de valeurs, d’entrée, en un nouvel
ensemble de valeurs, de sortie.
Exemples d’algorithmes :
I Une recette de cuisine (ingrédients → plat préparé)
I La recherche dans un dictionnaire (mot → définition)
I La division entière (deux entiers → leur quotient)
I Le tri d’une séquence (séquence → séquence ordonnée)
Introduction 10
Algorithmes
On étudiera essentiellement les algorithmes corrects.

I Un algorithme est (totalement) correct lorsque pour chaque instance,
il se termine en produisant la bonne sortie.
I Il existe également des algorithmes partiellement corrects dont la
terminaison n’est pas assurée mais qui fournissent la bonne sortie
lorsqu’ils se terminent.
I Il existe également des algorithmes approximatifs qui fournissent une
sortie inexacte mais néanmoins proche de l’optimum.
Les algorithmes seront évalués en termes d’utilisation de resources,

essentiellement par rapport aux temps de calcul mais aussi à
l’utilisation de la mémoire.
Introduction 11
Algorithmes
Un algorithme peut être spécifié de différentes manières :

en langage naturel,
graphiquement,
en pseudo-code,
par un programme écrit dans un langage informatique
...
La seule condition est que la description soit précise.
Introduction 12
Exemple : le tri
Le problème de tri :
I Entrée : une séquence de n nombres ha1 , a2 , . . . , an i
I Sortie : une permutation de la séquence de départ ha10 , a20 , . . . , an0 i
telle que a10 ≤ a20 ≤ . . . ≤ an0
Exemple :
I Entrée : h31, 41, 59, 26, 41, 58i
I Sortie : h26, 31, 41, 41, 58, 59i
Introduction 13
Tri par insertion
Description en langage naturel :
On parcourt la séquence de gauche à droite
Pour chaque élément aj :

On l’insère à sa position dans une nouvelle séquence ordonnée
contenant les éléments le précédant dans la séquence.
On s’arrête dès que le dernier élément a été inséré à sa place dans la
séquence.
Introduction 14
Tri par insertion
Insertion Sort
5 2 4 6 1 3
2 5 4 6 1 3
2 4 5 6 1 3
2 4 5 6 1 3
1 2 4 5 6 3
1 2 3 4 5 6
Intro to Data Structures and Algorithms © Introdu

Introduction 15
Tri par insertion
Description en C (sur des tableaux d’entiers) :
void InsertionSort (int *a, int length) {

int key, i;
for(int j = 1; j < length; j++) {
key = a[j];
/* Insert a[j] into the sorted sequence a[0...j-1] */
i = j-1;
while (i>=0 && a[i]>key) {
a[i+1] = a[i];
i = i-1;
}
a[i+1] = key;
}
}
Introduction 16
Insertion sort
Description en pseudo-code (sur des tableaux d’entiers) :
Insertion-Sort(A)
1 for j = 2 to A.length
2 key = A[j]
3 // Insert A[j] into the sorted sequence A[1 . . j − 1].
4 i = j −1
5 while i > 0 and A[i] > key
6 A[i + 1] = A[i]
7 i = i −1
8 A[i + 1] = key
Introduction 17
Pseudo-code
Objectifs :
Décrire les algorithmes de manière à ce qu’ils soient compris par des
humains.
Rendre la description indépendante de l’implémentation
S’affranchir de détails tels que la gestion d’erreurs, les déclarations

de type, etc.
Très proche du C (langage procédural plutôt qu’orienté objet)
Peut contenir certaines instructions en langage naturel si nécessaire
Introduction 18
Pseudo-code
Quelques règles
Structures de blocs indiquées par l’indentation
Boucles (for, while, repeat ) et conditions (if, else, elseif) comme
en C.
Le compteur de boucle garde sa valeur à la sortie de la boucle
En sortie d’un for, le compteur a la valeur de la borne max+1.
i =1
for i = 1 to Max while i ≤ Max
⇔
Code Code
i = i +1
Commentaires indiqués par //
Affectation (=) et test d’égalité (==) comme en C.
Introduction 19
Pseudo-code
Les variables (i, j et key par exemple) sont locales à la fonction.

A[i] désigne l’élément i du tableau A. A[i..j] désigne un intervalle de
valeurs dans un tableau. A.length est la taille du tableau.
L’indexation des tableaux commence à 1.
Les types de données composés sont organisés en objets, qui sont
composés d’attributs. On accède à la valeur de l’attribut attr pour
un objet x par x.attr .
Un variable représentant un tableau ou un objet est considérée
comme un pointeur vers ce tableau ou cet objet.
Paramètres passés par valeur comme en C (mais tableaux et objets
sont passés par pointeur).
...
Introduction 20
Trois questions récurrentes face à un algorithme
1. Mon algorithme est-il correct, se termine-t-il ?
2. Quelle est sa vitesse d’exécution ?
3. Y-a-t’il moyen de faire mieux ?
Exemple du tri par insertion

1. Oui → technique des invariants (partie 2)
2. O(n2 ) → analyse de complexité (partie 2)
3. Oui → il existe un algorithme O(n log n) (partie 1)
Introduction 21
Correction de Insertion-Sort
Insertion-Sort(A)
2 key = A[j]
3 i = j −1
5 A[i + 1] = A[i]
6 i = i −1
7 A[i + 1] = key
Invariant : (pour la boucle externe) le sous-tableau A[1 . . j − 1]

contient les éléments du tableau original A[1 . . j − 1] ordonnés.
On doit montrer que
I l’invariant est vrai avant la première itération
I l’invariant est vrai avant chaque itération suivante
I En sortie de boucle, l’invariant implique que l’algorithme est correct
Introduction 22
Correction de Insertion-Sort
Avant la première itération :

I j = 2 ⇒ A[1] est trivialement ordonné.
Avant la jème itération :

I Informellement, la boucle interne déplace A[j − 1], A[j − 2],
A[j − 3] . . . d’une position vers la droite jusqu’à la bonne position
pour key (A[j]).
En sortie de boucle :
I A la sortie de boucle, j = A.length + 1. L’invariant implique que
A[1 . . A.length] est ordonné.
Introduction 23
Complexité de Insertion-Sort
Insertion-Sort(A)
2 key = A[j]
3 i = j −1
5 A[i + 1] = A[i]
6 i = i −1
7 A[i + 1] = key
Nombre de comparaisons T (n) pour trier un tableau de taille n ?

Dans le pire des cas :
I La boucle for est exécutée n − 1 fois (n = A.length).
I La boucle while est exécutée j − 1 fois
Introduction 24
Complexité de Insertion-Sort
Le nombre de comparaisons est borné par :

n
X
T (n) ≤ (j − 1)
j=2
Pn
Puisque i=1 i = n(n + 1)/2, on a :
n(n − 1)
T (n) ≤
2
Finalement, T (n) = O(n2 )
(borne inférieure ?)
Introduction 25
Structures de données
Méthode pour stocker et organiser les données pour en faciliter

l’accès et la modification
Une structure de données regroupe :
I un certain nombre de données à gérer, et
I un ensemble d’opérations pouvant être appliquées à ces données
Dans la plupart des cas, il existe
I plusieurs manières de représenter les données et
I différents algorithmes de manipulation.
On distingue généralement l’interface des structures de leur
implémentation.
Introduction 26
Types de données abstraits
Un type de données abstrait (TDA) représente l’interface d’une

structure de données.
Un TDA spécifie précisément :
I la nature et les propriétés des données
I les modalités d’utilisation des opérations pouvant être effectuées
En général, un TDA admet différentes implémentations (plusieurs
représentations possibles des données, plusieurs algorithmes pour les
opérations).
Introduction 27
Exemple : file à priorités
Données gérées : des objets avec comme attributs :
I une clé, munie d’un opérateur de comparaison selon un ordre total
I une valeur quelconque
Opérations :
I Création d’une file vide
I Insert(S, x) : insère l’élément x dans la file S.
I Extract-Max(S) : retire et renvoie l’élément de S avec la clé la
plus grande.
Il existe de nombreuses façons d’implémenter ce TDA :

I Tableau non trié ;
I Liste triée ;
I Structure de tas ;
I ...
Chacune mène à des complexités différentes des opérations Insert
et Extract-Max
Introduction 28
Structures de données et algorithmes en pratique
La résolution de problème algorithmiques requiert presque toujours
la combinaison de structures de données et d’algorithmes
sophistiqués pour la gestion et la recherche dans ces structures.
D’autant plus vrai qu’on a à traiter des volumes de données
importants.
Quelques exemples de problèmes réels :
I Routage dans les réseaux informatiques
I Moteurs de recherche
I Alignement de séquences ADN en bio-informatique
Introduction 29
Plan
1. Algorithms + Data structures = Programs (Niklaus Wirth)
2. Introduction à la récursivité
Introduction 30
Algorithmes récursifs
Un algorithme est récursif s’il s’invoque lui-même directement ou
indirectement.
Motivation : Simplicité d’expression de certains algorithmes
Exemple : Fonction factorielle :

1 si n = 0
n! =
n · (n − 1)! si n > 0
Factorial(n)
1 if n == 0
2 return 1
3 return n · Factorial(n − 1)
Introduction 31
Factorial(n)
1 if n == 0
2 return 1
3 return n · Factorial(n − 1)
Règles pour développer une solution récursive :
On doit définir un cas de base (n == 0)

On doit diminuer la “taille” du problème à chaque étape (n → n − 1)
Quand les appels récursifs se partagent la même structure de
données, les sous-problèmes ne doivent pas se superposer (pour
éviter les effets de bord)
Introduction 32
Exemple de récursion multiple
Calcul du kième nombre de Fibonacci :
F0 = 0
F1 = 1
∀i ≥ 2 : Fi = Fi−2 + Fi−1
Algorithme :
Fibonacci(n)
1 if n ≤ 1
2 return n
3 return Fibonacci(n − 2) + Fibonacci(n − 1)
Introduction 33
Fibonacci(n)
1 if n ≤ 1
2 return n
1. L’algorithme est-il correct ?

Introduction 34
Fibonacci(n)
1 if n ≤ 1
2 return n
1. L’algorithme est correct ?

I Clairement, l’algorithme est correct.
I En général, la correction d’un algorithme récursif se démontre par
induction.
Introduction 35
Vitesse d’exécution
Nombre d’opérations pour calculer Fibonacci(n) en fonction de n
Results
Empiriquement :
60
Ruby
Python
50 Scheme
C
Time (seconds)
40 C-wiz
Java
C-gcc
30
20
10
0
20 25 30 35 40 45 50
n
© 2006 (Carzaniga)
Antonio Carzaniga
Toutes les implémentations atteignent leur limite, plus ou moins loin

Introduction 36
Trace d’exécution
Trace d’exécution :
fibonacci1(k)
fibonacci1(k 2) fibonacci1(k 1)
fibonacci1(k 4) fibonacci1(k 3) fibonacci1(k 3) fibonacci1(k 2)
(Boigelot)
p
1+ 5
Temps de calcul : O('n), où ' = .
2
Preuve ?
Introduction 32 37
Complexité
Fibonacci(n)
1 if n ≤ 1
2 return n
Soit T (n) le nombre d’opérations de base pour calculer

Fibonacci(n) :
T (0) = 2, T (1) = 2
T (n) = T (n − 1) + T (n − 2) + 2
On a donc T (n) ≥ Fn (= le nème nombre de Fibonacci).
Introduction 38
Complexité
Comment croı̂t Fn avec n ?
T (n) ≥ Fn = Fn−1 + Fn−2
Puisque Fn ≥ Fn−1 ≥ Fn−2 ≥ . . .

n
Fn ≥ 2Fn−2 ≥ 2(2Fn−4 ) ≥ 2(2(2Fn−6 )) ≥ 2 2
Et donc √
T (n) ≥ ( 2)n ≈ (1.4)n
T (n) croı̂t exponentiellement avec n
Peut-on faire mieux ?
Introduction 39
Solution itérative
Fibonacci-Iter(n)
1 if n ≤ 1
2 return n
3 else
4 pprev = 0
5 prev = 1
6 for i = 2 to n
7 f = prev + pprev
8 pprev = prev
9 prev = f
10 return f
Introduction 40
Complexité : O(n) Results
60
Ruby
Python
50 Scheme
C
Time (seconds)
40 C-wiz
Java
C-gcc
30 PythonSmart
20
10
0
0 20 40 60 80 100
n
© 2006
(Carzaniga)
Antonio Carzaniga
Introduction 41
Tri par fusion
Idée d’un tri basé sur la récursion :
on sépare le tableau en deux sous-tableaux de la même taille
on trie (récursivement) chacun des sous-tableaux
on fusionne les deux sous-tableaux triés en maintenant l’ordre
Le cas de base correspond à un tableau d’un seul élément.
merge-sort(A, p, r )
1 if p < r
2 q = b p+r
2 c
3 merge-sort(A, p, q)
4 merge-sort(A, q + 1, r )
5 merge(A, p, q, r )
Appel initial : merge-sort(A, 1, A.length)
Exemple d’application du principe général de “diviser pour régner”

Introduction 42
Bottom-up view for n D 8: [Heavy lines demarc
Tri par fusion : illustration
lems.]
sorted array
1 2 3 4 5 6 7 8
1 2 2 3 4 5 6 7
merge
2 4 5 7 1 2 3 6
merge
2 5 4 7 1 3 2 6
merge
5 2 4 7 1 3 2 6
1 2 3 4 5 6 7 8
initial array
Introduction
[Examples when n is a power of 2 are most stra
43
Fonction merge
Merge(A, p, q, r ) :
Entrée : tableau A et indice p, q, r tels que :
I p ≤ q < r (pas de tableaux vides)
I Les sous-tableaux A[p . . q] et A[q + 1 . . r ] sont ordonnés
Sortie : Les deux sous-tableaux sont fusionnés en seul sous-tableau
ordonné dans A[p . . r ]
Idée :
Utiliser un pointeur vers le début de chacune des listes ;
Déterminer le plus petit des deux éléments pointés ;
Déplacer cet élément vers le tableau fusionné ;
Avancer le pointeur correspondant
Introduction 44
Fusion : algorithme
Merge(A, p, q, r )
1 n1 = q − p + 1 ; n2 = r − q
2 Soit L[1..n1 + 1] and R[1..n2 + 1] deux nouveaux tableaux
3 for i = 1 to n1
4 L[i] = A[p + i − 1]
5 for j = 1 to n2
6 R[j] = A[q + j]
7 L[n1 + 1] = ∞ ; R[n2 + 1] = ∞ // Sentinels
8 i=1 ;j=1
9 for k = p to r
10 if L[i] ≤ R[j]
11 A[k] = L[i]
12 i = i +1
13 else
14 A[k] = R[j]
15 j = j +1
Introduction 45
Merge Sort
Fusion : illustration
Illustration of Merge
n1=q-p+1 elem. n2=r-q elem.

p q q+1 r
Abefore ... ...
L R
1 2 ... n1 n1+1 1 ... n2 n2+1
p q q+1 r
Aafter ... ...
n = r-p+1 elements Data Structures and Algorithms (89)
Complexité : O(n) (où n = r − p + 1)
Introduction 46
Complexité de merge-sort : O(n log n) (voir partie 2)
5
x 10
2.5
Insertion Sort
Merge Sort
2
Complexity
1.5
0.5
0
0 50 100 150 200 250 300 350 400 450 500
n
Introduction 47
Remarques
La fonction merge nécessite d’allouer deux tableaux L et R (dont

la taille est O(n)). Exercice (difficile) : écrire une fonction merge
qui ne nécessite pas d’allocation supplémentaire.
On pourrait réécrire merge-sort de manière itérative (au prix de la
simplicité)
Version récursive du tri par insertion :
Insertion-Sort-rec(A, n)
1 if n > 1
2 Insertion-Sort-rec(A, n − 1)
3 Merge(A, 1, n − 1, n)
Introduction 48
Note sur l’implémentation de la récursivité
Trace d’exécution
Trace de: la factorielle
d’exécution
factorial(n)
factorial(n 1)
factorial(2)
factorial(1)
Chaque appel
Temps récursif
de calcul nécessite
: O(n) de mémoriser
(en supposant le contexte
des opérations arithmétiques en
temps constant!).
d’invocation
L’espace
Espacemémoire
mémoire utilisé
utilisé :est donc O(n) (n appels récursifs)
O(n).
En e↵et, chaque appel récursif de factorial nécessite de mémoriser son

contexte d’invocation.
Introduction 49
Récursivité terminale
Définition : Une procédure est récursive terminale (tail récursive) si

elle n’effectue plus aucune opération après s’être invoquée
récursivement.
Avantages :
I Le contexte d’invocation ne doit pas être mémorisé et donc l’espace
mémoire nécessaire est réduit
I Les procédures récursives terminales peuvent facilement être
converties en procédures itératives
Introduction 50
Version récursive terminale de la factorielle
Factorial2(n)
1 return Factorial2-rec(n, 2, 1)
Factorial2-rec(n, i, f )
1 if i > n
2 return f
3 return Factorial2-rec(n, i + 1, f · i)
Espace mémoire utilisé : O(1) (si la récursion terminale est implémentée

efficacement)
Introduction 51
Ce qu’on a vu
Définitions générales : algorithmes, structures de données, structures

de données abstraites...
Analyse d’un algorithme itératif (Insertion-Sort)
Notions de récursivité
Analyse d’un algorithme récursif (Fibonacci)
Tri par fusion (MergeSort)
Introduction 52
Partie 2
Outils d’analyse
Outils d’analyse 53
Plan
1. Correction d’algorithmes
2. Complexité algorithmique
Plan
Introduction
Algorithmes itératifs
Introduction
Notations asymptotiques
Complexité d’algorithmes et de problèmes
Complexité d’algorithmes itératifs
Complexité d’algorithmes récursifs
Analyse d’algorithmes
Questions à se poser lors de la définition d’un algorithme :

Mon algorithme est-il correct ?
Mon algorithme est-il efficace ?
Autre question importante seulement marginalement abordée dans ce

cours :
Modularité, fonctionnalité, robustesse, facilité d’utilisation, temps de
programmation, simplicité, extensibilité, fiabilité, existence d’une
solution algorithmique...
Correction d’un algorithme
La correction d’un algorithme s’étudie par rapport à un problème

donné
Un problème est une collection d’instances de ce problème.
I Exemple de problème : trier un tableau
I Exemple d’instance de ce problème : trier le tableau [8, 4, 15, 3]
Un algorithme est correct pour une instance d’un problème s’il
produit une solution correcte pour cette instance
Un algorithme est correct pour un problème s’il est correct pour
toutes ses instances (on dira qu’il est totalement correct)
On s’intéressera ici à la correction d’un algorithme pour un problème
(et pas pour seulement certaines de ses instances)
Comment vérifier la correction ?
Première solution : en testant concrètement l’algorithme :

I Suppose d’implémenter l’algorithme dans un langage (programme) et
de le faire tourner
I Supppose qu’on peut déterminer les instances du problème à vérifier
I Il est très difficile de prouver empiriquement qu’on n’a pas de bug
Deuxième solution : en dérivant une preuve mathématique formelle :
I Pas besoin d’implémenter et de tester toutes les instances du
problème
I Sujet à des “bugs” également
En pratique, on combinera les deux
Outils pour prouver la correction d’un algorithme :

I Algorithmes itératifs : triplets de Hoare, invariants de boucle
I Algorithmes récursifs : preuves par induction
Assertion
Relation entre les variables qui est vraie à un moment donné dans
l’exécution
Assertions particulières :
I Pre-condition P : conditions que doivent remplir les entrées valides de
l’algorithme
I Post-condition Q : conditions qui expriment que le résultat de
l’algorithme est correct
P et Q définissent resp. les instances et solutions valides du
problème
Un code est correct si le triplet (de Hoare) {P} code {Q} est vrai.
Exemple :
{x ≥ 0}y = sqrt(x){y 2 == x}
Correction : séquence d’instructions
{P}
S1
S2
...
Sn
{Q}
Pour vérifier que le triplet est correct :

on insère des assertions P1 , P2 , . . . , Pn décrivant l’état des variables
à chaque étape du programme
on vérifie que les triplets {P} S1 {P1 }, {P1 } S2 {P2 }, . . .,
{Pn−1 } Sn {Q} sont corrects
Trois types d’instructions : affectation, condition, boucle
Correction : affectations
{P}
x =e
{Q}
Pour prouver que le triplet est correct, il faut montrer qu’on peut dériver
Q à partir de P en remplaçant x par e.
Exemple :
{x = = 2}
y = x +1
{y = = 3}
Correction : conditions
{P}
if B
C1
else
C2
{Q}
Pour prouver que le triplet est correct, on doit prouver que

{P et B} C1 {Q}
{P et non B} C2 {Q}
sont corrects
Exemple :
{x < 6}
if x < 0
y =0
else
y =x
{0 ≤ y < 6}
Correction : boucles
{P}
{P} INIT
INIT {I }
while B while B
CORPS {I et B} CORPS {I }
FIN {I et non B}
{Q} FIN
{Q}
Pour prouver que le triplet est correct :
On met en évidence une assertion particulière I , appelée invariant de
boucle, qui décrit l’état du programme pendant la boucle.
On prouve que :
I {P} INIT {I } est correct
I {I et B} CORPS {I } est correct
I {I et non B} FIN {Q} est correct
Si on a plusieurs boucles imbriquées, on les traite séparément, en

démarrant avec la boucle la plus interne.
Correction : terminaison de boucle
INIT
while B
CORPS
FIN
Un fois qu’on a prouvé que le triplet était correct, il faut encore

montrer que la boucle se termine
Pour prouver la terminaison, on cherche une fonction de terminaison
f :
I définie sur base des variables de l’algorithme et à valeur entière
naturelle (≥ 0)
I telle que f décroı̂t strictement suite à l’exécution du corps de la
boucle
I telle que B implique f > 0
Puisque f décroı̂t strictement, elle finira par atteindre 0 et donc à
infirmer B.
Exemple : Fibonacci-iter
Réécriture, post- et
pré-conditions
Fibonacci-Iter(n)
if n ≤ 1 Fibonacci-Iter(n)
return n {n ≥ 0} // {P}
else if n ≤ 1
pprev = 0 prev = n
prev = 1 else
for i = 2 to n pprev = 0
f = prev + pprev prev = 1
pprev = prev i =2
prev = f while (i ≤ n)
return f f = prev + pprev
pprev = prev
Proposition : Si n ≥ 0, prev = f
Fibonacci-iter(n) renvoie i = i +1
{prev == Fn } // {Q}
Fn .
return prev
Analyse de la condition Analyse de la boucle
{n ≥ 0 et n ≤ 1} {n > 1}
prev = n pprev = 0
{prev == Fn } prev = 1
i =2
correct (F0 = 0, F1 = 1)
{pprev == Fi−2 , prev = = Fi−1 }
correct
{n ≥ 0 et n > 1}
pprev = 0 {pprev = = Fi−2 , prev = = Fi−1 , i ≤ n}
prev = 1 f = prev + pprev
i =2 pprev = prev
while (i ≤ n) prev = f
f = prev + pprev i = i +1
pprev = prev {pprev = = Fi−2 , prev = = Fi−1 }
prev = f correct
i = i +1
{prev == Fn } {pprev = = Fi−2 , prev = = Fi−1 , i = = n + 1}
{prev = = Fn }
I = {pprev = = Fi−2 , prev = = Fi−1 }
correct
i =2
while (i ≤ n)
f = prev + pprev
pprev = prev
prev = f
i = i +1
Fonction de terminaison f = n − i + 1 :
I i ≤n ⇒f =n−i +1>0
I i = i + 1 ⇒ f diminue à chaque itération
L’algorithme est donc correct et se termine.
Exemple : tri par insertion
Insertion-Sort(A)
2 key = A[j]
3 // Insert A[j] into the sorted sequence A[1 . . j − 1].
4 i = j −1
6 A[i + 1] = A[i]
7 i = i −1
8 A[i + 1] = key
Démontrons informellement que la boucle externe est correcte

Invariant I : le sous-tableau A[1 . . j − 1] contient les éléments du
tableau original A[1 . . j − 1] ordonnés.
j =2
for j = 2 to A.length while i ≤ A.length
⇔
... ...
j = j +1
P =”A est un tableau de taille A.length”,
Q =”Le tableau A est trié”,
I =”A[1 . . j − 1] contient les j − 1 premiers éléments de A triés”
{P}j = 2{I } (avant la boucle)

I j = 2 ⇒ A[1] est trivialement ordonné
{I et j ≤ A.length} CORPS {I } (pendant la boucle)

I La boucle interne déplace A[j − 1], A[j − 2], A[j − 3] . . . d’une position
vers la droite jusqu’à trouver la bonne position pour key (A[j]).
I A[1 . . j] contient alors les éléments originaux de A[1 . . j] triés.
I j = j + 1 rétablit l’invariant
{I et j = A.length + 1}{Q} (après la boucle)
I Puisque j = A.length + 1, l’invariant implique que A[1 . . A.length] est
ordonné.
Fonction de terminaison f = A.length − j + 1
Invariant
Un invariant peut être difficile à trouver pour certains algorithmes

En général, l’algorithme découle de l’invariant et pas l’inverse
I Fibonacci-iter : On calcule itérativement Fi−1 et Fi−2
(I = {pprev == Fi−2 , prev == Fi−1 })
I Insertion-sort : On ajoute l’élément j aux j − 1 premiers éléments
déjà triés
(I =”A[1 . . j − 1] contient les j − 1 premiers éléments de A triés”)
La preuve par invariant est basée sur le principe général de preuve

par induction qu’on va utiliser aussi pour prouver la correction des
algorithmes récursifs
Initialisation Maintenance Terminaison
It. 1 It. 2 It. 3 It. 4 It. 5
Preuve par induction
Cas$induc,f$
Cas$de$base$ …$
On veut montrer qu’une propriété est vraie pour une série

d’instances
On suppose l’existence d’un ordonnancement des instances
Cas de base : on montre explicitement que la propriété est vraie
pour la ou les premières instances
Cas inductif : on suppose que la propriété est vraie pour les k
premières instances et on montre qu’elle l’est alors aussi pour la
k + 1-ième instance (quel que soit k)
Par le principe d’induction, la propriété sera vraie pour toutes les
instances
Preuve par induction : exemple
Proposition : Pour tout n ≥ 0, on a
n
X n(n + 1)
i=
2
i=1
Démonstration :
P
Cas de base : n = 0 ⇒ 0i=1 i = 0 = 0(0+1) 2
Cas inductif : Supposons la propriété vraie pour n et montrons
qu’elle est vraie pour n + 1 :
n+1 n
!
X X n(n + 1)
i = i + (n + 1) = + (n + 1)
2
i=1 i=1
(n + 1)(n + 2)
=
2
Par induction, le propriété est vraie pour tout n.
Correction d’algorithmes récursifs par induction
Propriété à montrer : l’algorithme est correct pour une instance

quelconque du problème
Instances du problème ordonnées par “taille” (taille du tableau,
nombre de bits, un entier n, etc.)
Cas de base de l’induction = cas de base de la récursion
Cas inductif : on suppose que les appels récursifs sont corrects et on
en déduit que l’appel courant est correct
Terminaison : on montre que les appels récursifs se font sur des
sous-problèmes (souvent trivial)
Exemple : Fibonacci
Fibonacci(n)
1 if n ≤ 1
2 return n
Proposition : Pour tout n, Fibonacci(n) renvoie Fn .

Démonstration :
Cas de base : pour n = 0, Fibonacci(n) renvoie F0 = 0. For n = 1,
Fibonacci(n) renvoie F1 = 1.
Cas inductif :
I Supposons n ≥ 2 et que pour tout 0 ≤ m < n, Fibonacci(m)
renvoie Fm .
I Pour n ≥ 2, Fibonacci(n) renvoie
Fibonacci(n − 2) + Fibonacci(n − 1)
= Fn−2 + Fn−1 (par hypothèse inductive)
= Fn .
Exemple : merge sort
1 if p < r
2 q = b p+r
2 c
Proposition : Pour tout 1 ≤ p ≤ r ≤ A.length, merge-sort(A, p, r ) trie

le sous-tableau A[p . . r ].
(On supposera que Merge est correct mais il faudrait le démontrer par
un invariant)
Exemple : merge sort
1 if p < r
2 q = b p+r
2 c
Démonstration :
Cas de base : pour r − p = 0, merge-sort(A, p, r ) ne modifie pas
A et donc A[p] = A[q] est trivialement trié
Cas inductif :
I Supposons r − p > 0 et que pour tout 1 ≤ p 0 ≤ r 0 ≤ A. length tels
que r 0 − p 0 < r − p, merge-sort(A, p 0 , r 0 ) trie A[p 0 . . r 0 ]
I Les appels merge-sort(A, p, q) et merge-sort(A, q + 1, r ) sont
corrects par hypothèse inductive (puisque q − p < r − p et
r − q + 1 < r − p)
I En supposant Merge correct, merge-sort(A, p, r ) est correct.
Conclusion sur la correction
Preuves de correction :
I Algorithmes itératifs : invariant (=induction)
I Algorithmes récursifs : induction
Malheureusement, il n’existe pas d’outil automatique pour vérifier la

correction (et la terminaison) d’algorithmes
Dans la suite, on ne présentera des invariants ou des preuves par
induction que très sporadiquement lorsque ce sera nécessaire (cas
non triviaux)
Plan
Introduction
Algorithmes itératifs
Introduction
Complexité d’algorithmes et de problèmes
Complexité d’algorithmes itératifs
Performance d’un algorithme
Plusieurs métriques possibles :

I Longueur du programme (nombre de lignes)
I Simplicité du code
I Espace mémoire consommé
I Temps de calcul
I ...
Les temps de calcul sont la plupart du temps utilisés

I Ils peuvent être quantifiés et sont faciles à comparer
I Souvent ce qui compte réellement
Nous étudierons aussi l’espace mémoire consommé par nos
algorithmes
Comment mesurer les temps d’exécution ?
Expérimentalement :
On écrit un programme qui implémente l’algorithme et on l’exécute
sur des données
Problèmes :
I Les temps de calcul vont dépendre de l’implémentation : CPU, OS,
langage, compilateur, charge de la machine, OS, etc.
I Sur quels données tester l’algorithme ? Results
60
Ruby
Python
50 Scheme
C
Time (seconds)
40 C-wiz
Java
C-gcc
30
20
10
0
20 25 30 35 40 45 50
n
© 2006 Antonio Carzaniga (Carzaniga)
En se basant sur un modèle de calcul abstrait :

Random-access machine (RAM) :
I Types de données de base :
I Entiers et nombres flottants
I Chaque mot est de taille limitée (par ex, 64 bits)
I Opérations de base de la machine :
I addition, soustraction, multiplication...
I affectation, accès à un élément d’un tableau...
I branchement conditionnel, saut
I appel de sous-routines, renvoi d’une valeur
I Les opérations sont exécutées les unes après les autres (pas de
parallélisme)
I Les opérations de base prennent un temps constant
Calculer les temps de calcul = sommer le temps d’exécution associé

à chaque instruction du pseudo-code
Modèle RAM :
I Opérations de base : temps constant
I Appel de sous-routines : temps de l’appel (constant) + temps de
l’exécution de la sous-routine (calculé récursivement)
Le temps dépend de l’entrée (l’instance particulière du problème)

On étudie généralement les temps de calcul en fonction de la
“taille” de l’entrée
I Généralement, le nombre de valeurs pour la décrire
I Mais ça peut être autre chose (Ex : n pour Fibonacci)
Chapter 2 Getting Started
Analyse du tri par insertion
I NSERTION -S ORT .A/ cost times
1 for j D 2 to A:length c1 n
2 key D AŒj ! c2 n!1
3 // Insert AŒj ! into the sorted
sequence AŒ1 : : j ! 1!. 0 n!1
4 i D j !1 c4 P! 1
n
5 while i > 0 and AŒi! > key
n
c5 t
PjnD2 j
6 AŒi C 1! D AŒi! c6 .t ! 1/
PjnD2 j
7 i D i !1 c7 j D2 j ! 1/
.t
8 AŒi C 1! D key c8 n!1
tj = The running
nombre de time of the
fois que la algorithm
conditionisdu thewhile
sum ofestrunning
testée.times for each sta
ment executed;
Temps exécutiona T
statement
(n) (pour thatun
takes ci steps
tableau detotaille
execute
n) and executes
donné par : n times w
contribute ci n to the total running time.6 To computen T .n/,
n the running time
I NSERTION
T (n) -S= ORTc1 n on
+ can
2 (ninput ofc4n(nvalues,
− 1) + we
c5 sum thec6 products of the cost
X X
− 1) + tj + (tj − 1)
times columns, obtaining j=2 j=2
n
n
X n
X
X
+c7 (tj − 1) + c8 (n − 1)
T .n/ D c1 n C c2j=2
.n ! 1/ C c4 .n ! 1/ C c5 tj C c6 .tj ! 1/
j D2 j D2
Outils d’analyse n 84
Différents types de complexité
Même pour une taille fixée, la complexité peut dépendre de

l’instance particulière
Soit Dn l’ensemble des instances de taille n d’un problème et T (in )
le temps de calcul pour une instance in ∈ Dn .
Sur quelles instances les performances d’un algorithme devraient
être jugées :
I Cas le plus favorable (best case) : T (n) = min{T (in )|in ∈ Dn }
I Cas le plus défavorable (worst case) P
: T (n) = max{T (in )|in ∈ Dn }
I Cas moyen (average case) : T (n) = in ∈Dn Pr (in )T (in ) où Pr (in ) est
la probabilité de rencontrer in
On se focalise généralement sur le cas le plus défavorable
I Donne une borne supérieure sur le temps d’exécution.
I Le meilleur cas n’est pas représentatif et le cas moyen est difficile à
calculer.
Meilleur cas :
le tableau est trié ⇒ tj = 1.
Le temps de calcul devient :
T (n) = c1 n + c2 (n − 1) + c4 (n − 1) + c5 (n − 1) + c8 (n − 1)
= (c1 + c2 + c4 + c5 + c8 )n − (c2 + c4 + c5 + c8 )
T (n) = an + b ⇒ T (n) est une fonction linéaire de n
Pire cas :
le tableau est trié par ordre décroissant ⇒ tj = j.
Le temps de calcul devient :
„ «
n(n + 1)
T (n) = c1 n + c2 (n − 1) + c4 (n − 1) + c5 −1
2
„ « „ «
n(n − 1) n(n − 1)
+c6 + c7 + c8 (n − 1)
2 2
c5 c6 c7 c5 c6 c7
= ( + + )n2 + (c1 + c2 + c4 + − − + c8 )n
2 2 2 2 2 2
−(c2 + c4 + c5 + c8 )
T (n) = an2 + bn + c ⇒ T (n) est une fonction quadratique de n
Analyse asymptotique
On s’intéresse à la vitesse de croissance (“order of growth”) de T (n)
lorsque n croı̂t.
I Tous les algorithmes sont rapides pour des petites valeurs de n
On simplifie généralement T (n) :
I en ne gardant que le terme dominant
I Exemple : T (n) = 10n3 + n2 + 40n + 800
I T(1000)=100001040800, 10 · 10003 = 100000000000
I en ignorant le coefficient du terme dominant
I Asymptotiquement, ça n’affecte pas l’ordre relatif
6
x 10
10
1000*N
9
4*N2
8
N3
0.01*2N
7
0
100 200 300 400 500 600 700 800 900 1000
N
Exemple : Tri par insertion : T (n) = an2 + bn + c → n2 .

Pourquoi est-ce important ?
Supposons qu’on puisse traiter une opération de base en 1µs.

Temps d’exécution pour différentes valeurs de n
T(n) n = 10 n = 100 n = 1000 n = 10000

n 10µs 0.1ms 1ms 10ms
400n 4ms 40ms 0.4s 4s
2n2 200µs 20ms 2s 3.3m
n4 10ms 100s ∼ 11.5 jours 317 années
2n 1ms 4 × 1016 années 3.4 × 10287 années ...
(Dupont)
Pourquoi est-ce important ?
Taille maximale du problème qu’on peut traiter en un temps donné :
T(n) en 1 seconde en 1 minute en 1 heure
n 1 × 106 6 × 107 3.6 × 109
400n 2500 150000 9 × 106
2n2 707 5477 42426
n4 31 88 244
2n 19 25 31
Si m est la taille maximale que l’on peut traiter en un temps donné,

que devient cette valeur si on reçoit une machine 256 fois plus
puissante ?
T(n) Temps
n 256m
400n 256m
2n2 16m
n4 4m
2n m+8
(Dupont)
Permettent de caractériser le taux de croissance de fonctions

f : N → R+
Trois notations :
I Grand-O : f (n) ∈ O(g (n)) ≈ f (n) ≤ g (n)
I Grand-Omega : f (n) ∈ Ω(g (n)) ≈ f (n) ≥ g (n)
I Grand-Theta : f (n) ∈ Θ(g (n)) ≈ f (n) = g (n)
Notation grand-O
Asymptotic notation
O-notation
O(g (n)) = {f (n)|∃c > 0, ∃n0 ≥ 1 tels que 0 ≤ f (n) ≤ cg (n), ∀n ≥ n0 }
O.g.n// D ff .n/ W there exist positive constants c and n0 su
0 " f .n/ " cg.n/ for all n # n0 g :
cg(n)
f(n)
n
n0
g.n/ is an asymptotic upper bound for f .n/.

f (n) ∈ O(g (n)) ⇒ g If
(n) est2une
f .n/ bornewesupérieure
O.g.n//, write f .n/ asymptotique
D O.g.n// (willpour
precisely
f (n).
Par abus de notation, on écrira aussi : f (n) = O(g (n)).
n1:99999
Notation grand-Omega
n2 = lg lg lg n
!-notation
Ω(g (n)) = {f (n)|∃c > 0, ∃n0 ≥ 1 tels que 0 ≤ cg (n) ≤ f (n), ∀n ≥ n0 }
!.g.n// D ff .n/ W there exist positive constants c and n0 such
0 ! cg.n/ ! f .n/ for all n " n0 g :
f(n)
cg(n)
n
n0
g.n/ is an asymptotic lower bound for f .n/.

f (n) ∈ Ω(g (n)) ⇒ g (n) est une borne inférieure asymptotique pour
f (n). Example
Par abus de notation,pnonDécrira aussi
!.lg n/, with :c fD(n) = nΩ(g
1 and (n)).
0 D 16.
Outils d’analyse Examples of functions in !.n2 /: 93

Notation grand-Theta
Lecture Notes for Chapter 3: Growth of Functions
Θ(g (n)) = {f (n)|∃c 1 , c2 > 0, ∃n0 ≥ 1

‚-notation
tels que 0 ≤ c1 g (n) ≤ f (n) ≤ c2 g (n), ∀n ≥ n0 }
‚.g.n// D ff .n/ W there exist positive constants c1 , c2 , and n
0 ! c1 g.n/ ! f .n/ ! c2 g.n/ for all n "
c2g(n)
f(n)
c1g(n)
n
n0
is an asymptotically tight bound for f .n/.

f (n) ∈ Θ(g (n)) ⇒ gg.n/
(n) est une borne serrée (“tight”) asymptotique
pour f (n).
Par abus de notation,Example
on écrira aussi : f (n) = Θ(g (n)).
n2 =2 # 2n D ‚.n2 /, with c1 D 1=4, c2 D 1=2, and n0 D 8.
Exemples
3n5 − 16n + 2 ∈ O(n5 ) ? ∈ O(n) ? ∈ O(n17 ) ?
3n5 − 16n + 2 ∈ Ω(n5 ) ? ∈ Ω(n) ? ∈ Ω(n17 ) ?
3n5 − 16n + 2 ∈ Θ(n5 ) ? ∈ Θ(n) ? ∈ Θ(n17 ) ?
2n + 100n6 + n ∈ O(2n ) ? ∈ Θ(3n ) ? ∈ Ω(n7 ) ?
Classes de complexité :
O(1) ⊂ O(log n) ⊂ O(n) ⊂ O(n log n) ⊂ O(na>1 ) ⊂ (2n )
500
450
2n
n3
400
n2
350
n.log(n)
300 n
250
log(n)
200
150
100
50
0
5 10 15 20 25 30 35 40 45 50
Quelques propriétés
f (n) ∈ Ω(g (n)) ⇔ g (n) ∈ O(f (n))

f (n) ∈ Θ(g (n)) ⇔ f (n) ∈ O(g (n)) et f (n) ∈ Ω(g (n))
f (n) ∈ Θ(g (n)) ⇔ g (n) ∈ Θ(f (n))
Si f (n) ∈ O(g (n)), alors pour tout k ∈ N, on a k · f (n) ∈ O(g (n))

I Exemple : loga (n) ∈ O(logb (n)), an+b ∈ O(an )
Si f1 (n) ∈ O(g1 (n)) et f2 (n) ∈ O(g2 (n)), alors
f1 (n) + f2 (n) ∈ O(g1 (n) + g2 (n)) et f1 (n) + f2 (n) ∈ O(max{g1 (n), g2 (n)})
Pm i m
I Exemple :
i=1 ai n ∈ O(n )
Si f1 (n) ∈ O(g1 (n)) et f2 (n) ∈ O(g2 (n)), alors

f1 (n) · f2 (n) ∈ O(g1 (n) · g2 (n))
Complexité d’un algorithme
On utilise les notations asymptotiques pour caractériser la

complexité d’un algorithme.
Il faut préciser de quelle complexité on parle : générale, au pire cas,
au meilleur cas, en moyenne...
La notation grand-O est de loin la plus utilisée
I f (n) ∈ O(g (n)) sous-entend généralement que O(g (n)) est le plus
petit sous-ensemble qui contient f (n) et que g (n) est la plus concise
possible
I Exemple : n3 + 100n2 − n ∈ O(n3 ) = O(n3 + n2 ) ⊂ O(n4 ) ⊂ O(2n )
Idéalement, les notations O et Ω devraient être limitées au cas où
on n’a pas de borne serrée.
Complexité d’un algorithme
Exemples :
On dira :
“La complexité au pire cas du tri par insertion est Θ(n2 )”
plutôt que
“La complexité au pire cas du tri par insertion est O(n2 )”
ou “La complexité du tri par insertion est O(n2 )”
On dira
“La complexité au meilleur cas du tri par insertion est Θ(n)”
plutôt que
“La complexité au meilleur cas du tri par insertion est Ω(n)”
ou “La complexité du tri par insertion est Ω(n)”
Par contre, on dira “La complexité de Fibonacci est Ω(1.4n )”, car
on n’a pas de borne plus précise à ce stade.
Complexité d’un problème
Les notations asymptotiques servent aussi à caractériser la

complexité d’un problème
I Un problème est O(g (n)) s’il existe un algorithme O(g (n)) pour le
résoudre
I Un problème est Ω(g (n)) si tout algorithme qui le résoud est
forcément Ω(g (n))
I Un problème est Θ(g (n)) s’il est O(g (n)) et Ω(g (n))
Exemple du problème de tri :
I Le problème du tri est O(n log n) (voir plus loin)
I On peut montrer facilement que le problème du tri est Ω(n) (voir le
transparent suivant)
I On montrera plus tard que le problème de tri est en fait Ω(n log n) et
donc qu’il est Θ(n log n).
Exercice : montrez que la recherche du maximum dans un tableau
est Θ(n)
Le problème du tri est Ω(n)
Preuve par l’absurde (ou par contraposition) :

Supposons qu’il existe un algorithme moins que O(n) pour résoudre
le problème du tri
Cet algorithme ne peut pas parcourir tous les éléments du tableau,
sinon il serait au moins O(n)
Il y a donc au moins un élément du tableau qui n’est pas vu par cet
algorithme
Il existe donc des instances de tableau qui ne seront pas triées
correctement par cet algorithme
Il n’y a donc pas d’algorithme plus rapide que O(n) pour le tri.

Comment calculer la complexité en pratique ?
Quelques règles pour les algorithmes itératifs :

Affectation, accès à un tableau, opérations arithmétiques, appel de
fonction : O(1)
Instruction If-Then-Else : O(complexité max des deux branches)
Séquence d’opérations : l’opération la plus couteuse domine (règle
de la somme)
Boucle simple : O(nf (n)) si le corps de la boucle est O(f (n))

Comment calculer la complexité en pratique ?
Double boucle : O(n2 f (n)) où f (n) est la complexité du corps de la

boucle
Boucles incrémentales : O(n2 ) (si corps O(1))
for i = 1 to n
for j = 1 to i
...
Boucles avec un incrément exponentiel : O(log n) (si corps O(1))

i =1
while i ≤ n
...
i = 2i

Exemple :
prefixAverages(X ) :
Entrée : tableau X de taille n
Pi
X [j]
Sortie : tableau A de taille n tel que A[i] = j=1
i
prefixAverages(X )
prefixAverages2(X )
1 for i = 1 to X . length
1 s =0
2 a=0
2 for i = 1 to X . length
3 for j = 1 to i
3 s = s + X [i]
4 a = a + X [j]
4 A[i] = s/i
5 A[i] = a/i
5 return A
6 return A
Complexité : Θ(n)
Complexité : Θ(n2 )

La complexité d’algorithme récursif mène généralement à une

équation de récurrence
La résolution de cette équation n’est généralement pas triviale
On se contentera d’étudier quelques cas particuliers importants dans
ce cours

Factorial et Fibonacci
Factorial(n) Fib(n)
1 if n = = 0 1 if n ≤ 1
2 return 1 2 return n
3 return n · Factorial(n − 1) 3 return Fib(n − 2) + Fib(n − 1)
T (0) = c0 T (0) = c0 , T (1) = c0

T (n) = T (n − 1) + c1 T (n) = T (n − 1) + T (n − 2) + c1
= c1 n + c0
⇒ T (n) ∈ Θ(n)
⇒ T (n) ∈ Ω(1.4n )

Analyse du tri par fusion
1 if p < r
2 q = b p+r
2 c
Récurrence :
T (1) = c1 T (1) = Θ(1)

T (n) = 2T (n/2) + c2 n + c3 T (n) = 2T (n/2) + Θ(n)

2-16 Lecture Notes for Chapter 2: Getting Started
cn
Simplifions la récurrence en :
T (1) = c cn/2 cn/2
T (n) = 2T (n/2) + cn
lg n
On peut représenter la cn/4 cn/4 cn/4 cn/4
récurrence par un arbre de
récursion
La complexité est la somme du
coût de chaque noeud
c c c c c … c c
Total: cn l
2-16 Lecture Notes for Chapter 2: Getting Started
cn cn
cn/2 cn/2 cn
Chaque niveau a un coût
cn
lg n
En supposant que n est cn/4 cn/4 cn/4 cn/4 cn
une puissance de 2, il y a
log2 n + 1 niveaux
…
Le coût total est
cn log2 n + cn ∈ Θ(n log n) c c c c c … c c cn
Total: cn lg n + cn
! Each level has cost cn.

! The top level has cost cn.
! The next level down has 2 subproblems, each contributing cost
Outils d’analyse
! The next level has 4 subproblems, each contributing cost cn=4.
108
Remarques
Limitations de l’analyse asymptotique

Les facteurs constants ont de l’importance pour des problèmes de
petite taille
I Le tri par insertion est plus rapide que le tri par fusion pour n petit
Deux algorithmes de même complexité (grand-O) peuvent avoir des
propriétés très différentes
I Le tri par insertion est en pratique beaucoup plus efficace que le tri
par sélection sur des tableaux presque triés
Complexité en espace
S’étudie de la même manière, avec les mêmes notations
Elle est bornée par la complexité en temps (pourquoi ?)

Ce qu’on a vu
Correction d’algorithmes itératifs (par invariant) et récursifs (par

induction)
Notions de complexité algorithmique
Calcul de complexité d’algorithmes itératifs et récursifs

Partie 3
Algorithmes de tri
Algorithmes de tri 111

Plan
1. Algorithmes de tri
2. Tri rapide
3. Tri par tas

Introduction aux arbres
Tas
Tri par tas
4. Synthèse

Tri
Un des problèmes algorithmiques les plus fondamentaux.

En général, on veut trier des enregistrements avec une clé et des
données attachées.
Record1 Record2 Record3 Recordn
Key1 Key2 Key3 ... Keyn
Data1 Data2 Data3 Datan
Ici, on va ignorer ces données satellites et se focaliser sur les

algorithmes de tri
Le problème de tri :
I Entrée : une séquence de n nombres ha1 , a2 , . . . , an i
I Sortie : une permutation de la séquence de départ ha10 , a20 , . . . , an0 i
telle que a10 ≤ a20 ≤ . . . ≤ an0

Applications
Applications innombrables :
Tri des mails selon leur ancienneté
Tri des résultats de requête dans un moteur de recherche
Tri des facettes des objets pour l’affichage dans les jeux 3D
Gestion des opérations banquaires
...
Le tri sert aussi de brique de base pour d’autres algorithmes :

Recherche binaire dans un tableau trié
Recherche des éléments dupliqués dans une liste
Recherche du kème élément le plus grand dans une liste
...
Des études montrent qu’environ 25% du temps CPU des ordinateurs est
utilisé pour trier
Différents types de tri
Tri interne : tri en mémoire centrale. Tris externes : données sur

un disque externe.
Tri de tableau : tri qui trie un tableau. Extensible à toutes
structure de données offrant un accès en temps (quasi) constant à
ses éléments.
Tri générique : peut trier n’imporque quel type d’objets pour
autant qu’on puisse comparer ces objets.
Tri comparatif : basé sur la comparaison entre les éléments (clés)

Différents types de tri
Tri itératif : basé sur un ou plusieurs parcours itératif du tableau

Tri récursif : basé sur une procédure récursive
Tri en place : modifie directement la structure qu’il est en train de
trier. Ne nécessite qu’une quantité très limitée de mémoire
supplémentaire.
Tri stable : conserve l’ordre relatif des éléments égaux (au sens de
la méthode de comparaison).

Jusqu’ici
Algorithme Complexité En place ?

Pire Moyenne Meilleure
Insertion-Sort Θ(n2 ) Θ(n2 ) Θ(n) oui

Selection-Sort Θ(n2 ) Θ(n2 ) Θ(n2 ) oui
Bubble-Sort Θ(n2 ) Θ(n2 ) Θ(n) oui
Merge-Sort Θ(n log n) Θ(n log n) Θ(n log n) non
?? Θ(n log n) oui

?? Θ(n log n) oui

Tri rapide
Quicksort en anglais
Inventé par Hoare en 1960
Dans le top 10 des algorithmes du 20-ième siècle (SIAM)
L’exemple le plus célèbre de la technique du “diviser pour régner”
Tri en place, comme tri par insertion, et contrairement au tri par
fusion
Complexité : Θ(n2 ) dans le pire des cas, θ(n log n) en moyenne

QuickSort : principe
Pour trier un sous-tableau A[p . . r ] :

Partitionner A[p . . r ] en deux sous-tableaux : A[p..q − 1] et
A[q + 1 . . r ] tels que tout élément de A[p . . q − 1] est ≤ A[q] et
A[q] ≤ à tout élément de A[q + 1 . . r ].
(diviser)
Appeler récursivement l’algorithme pour trier A[p . . q − 1] et
A[q + 1 . . r ]
(régner)
Remarques :
A[q] est appelé le “pivot”
Par rapport au tri par fusion, il n’y a pas d’opération de combinaison

QuickSort : principe
1 p r A.length
partitionner
1 p q r A.length
 >
trier trier
p q 1 q q+1 r
 >

QuickSort Algorithm
QuickSort(A, p, r )
1 if p < r
2 q = Partition(A, p, r )
3 QuickSort(A, p, q − 1)
4 QuickSort(A, q + 1, r )
Appel initial : Quicksort(A, 1, A.length)

Partition : principe
p r
A x >x ? x
i j
On sélectionne le dernier élément A[r ] comme le pivot

On initialise un indice i à p − 1
On parcourt le tableau de gauche à droite avec un indice
j = p to r − 1
Si A[j] ≤ A[r ], on incrémente i et on échange A[j] et A[i]
En sortie de boucle, on échange A[i + 1] et A[r ] et on renvoie i + 1

Chapter 7 Quicksort
Partition : illustration
i p,j r
(a) 2 8 7 1 3 5 6 4
p,i j r
(b) 2 8 7 1 3 5 6 4
p,i j r
(c) 2 8 7 1 3 5 6 4
p,i j r A[r ] est le pivot

(d) 2 8 7 1 3 5 6 4 A[p . . i] : contient des éléments ≤ au le
p i j r pivot
(e) 2 1 7 8 3 5 6 4 A[i + 1 . . j − 1] contient des éléments >
p i j r que le pivot
(f) 2 1 3 8 7 5 6 4 A[p . . i] : est la partie du tableau non
p i j r
encore examinée
(g) 2 1 3 8 7 5 6 4
p i r
(h) 2 1 3 8 7 5 6 4
p i r
(i) 2 1 3 4 7 5 6 8

Partition : pseudo-code
Partition(A, p, r )
1 x = A[r ]
2 i = p−1
3 for j = p to r − 1
4 if A[j] ≤ x
5 i = i +1
6 swap(A[i], A[j])
7 swap(A[i + 1], A[r ])
8 return i + 1

Partition : correction
Partition(A, p, r )
1 x = A[r ]
2 i = p−1
4 if A[j] ≤ x
5 i = i +1
6 swap(A[i], A[j])
7 swap(A[i + 1], A[r ])
8 return i + 1
Pré-condition : {A[p . . r ], un tableau de nombres}

Post-condition : {A[p . . i] ≤ A[i + 1] < A[i + 2 . . r ]}
Invariant :
1. Les valeurs dans A[p . . i] sont ≤ au pivot
2. Les valeurs dans A[i + 1 . . j − 1] sont > que le pivot
3. A[r ] = pivot
Partition : correction
Avant la boucle : i = p − 1 et j = p ⇒ A[p . . i] et A[i + 1 . . j − 1] sont
vides
Pendant la boucle : p r
A x >x ? x
i j
Si A[j] > x, on incrémente juste j. Donc si l’invariant était vrai

avant l’exécution du corps, il reste vrai après.
Si A[j] ≤ x, on échange A[j] et A[i + 1] et i et j sont incrémentés.
L’invariant reste donc vérifié également
Après la boucle :
p r
A x >x x
i j
En sortie de boucle, l’invariant est vérifié et on a j = r . Echanger A[i + 1]
et A[r ] établit la post-condition.
Algorithme complet
Partition(A, p, r )
1 x = A[r ]
2 i = p−1
4 if A[j] ≤ x
5 i = i +1
6 swap(A[i], A[j])
7 swap(A[i + 1], A[r ])
8 return i + 1
QuickSort(A, p, r )
1 if p < r

Illustration
4 0 7 2 6 9 5 1 8 3
012 3 695784
01 2 69578 4
0 1 6 57 8 9
0 56 7
0 1 2 3 5 6 7 8 9 4

Complexité de Partition
Partition(A, p, r )
1 x = A[r ]
2 i = p−1
4 if A[j] ≤ x
5 i = i +1
6 swap(A[i], A[j])
7 swap(A[i + 1], A[r ])
8 return i + 1
T (n) = Θ(n)

Complexité de QuickSort
QuickSort(A, p, r )
1 if p < r
Pire cas : (quand se produit-il ?)

I q = p ou q = r
I Le partitionnement transforme un problème de taille n en un
problème de taille n − 1
T (n) = T (n − 1) + Θ(n)
I Même complexité que le tri par insertion :
T (n) = Θ(n2 )

Complexité de QuickSort
QuickSort(A, begin, end)

1 if begin < end
2 q = Partition(A, begin, end)
3 QuickSort(A, begin, q − 1)
4 QuickSort(A, q + 1, end)
Meilleur cas :
I q = bn/2c
I Le partitionnement transforme un problème de taille n en deux
problèmes de taille dn/2e et bn/2c − 1 respectivement
T (n) = 2T (n/2) + Θ(n)
I Même complexité que le tri par fusion :
T (n) = Θ(n log n)

Complexité moyenne de QuickSort
Complexité moyenne identique à la complexité du meilleur cas

Lecture Notes for Chapter 7: Quicksort 7-5
T (n) = Θ(n log n)

Intuition for the average case
Intuitivement
!
:
Splits in the recursion tree will not always be constant.
!
I En will
There moyenne,
usually on
be as’attend à une
mix of good andalternance de “bons”the
bad splits throughout etrecursion
de “mauvais”
tree.partitionnements
I La complexité d’un mauvais partitionnement suivi d’un bon est
! To see that this doesn’t affect the asymptotic running time of quicksort, assume
thatidentique à la between
levels alternate complexité d’une
best-case andbon partitionnement
worst-case splits. directement
(seule la constante est modifiée).
n
Θ(n) n Θ(n)
0 n–1
(n–1)/2 (n–1)/2
(n–1)/2 – 1 (n–1)/2
! The extra level in the left-hand figure only adds to the constant hidden in the
‚-notation.
Variantes de Quicksort
Choix du pivot :
I Prendre un élément au hasard plutôt que le dernier.
I Prendre la médiane de 3 éléments
I Diminue drastiquement les chances d’être dans le pire cas
Randomized-Partition(A, p, r )
1 i = Random(p, r )
2 swap(A[end], A[i])
3 return Partition(A, p, r )
Median-Of-3-Partition(A, p, r )
1 i = median(A, p, b(p + r )/2c, r )
2 swap(A[r ], A[i])
3 return Partition(A, p, r )

Variantes de Quicksort
Petits sous-tableaux
I Quicksort est trop lourd pour des petits tableaux
I Utiliser un tri naı̈f (par ex., par insertion) sur les sous-tableaux de
longueur inférieure à k (k ≈ 20).
QuickSort(A, p, r )
1 if r − p + 1 ≤ CUTOFF
2 InsertionSort(A, p, r )
3 return

Conclusion sur QuickSort
Rapide en moyenne Θ(n log n)

Pire cas en Θ(n2 ) mais très improbable avec choix du pivot bien fait
Bonne performance au niveau du cache
Tri en place (mais utilise de la mémoire pour la trace récursive)
Pas stable
En pratique souvent un peu plus rapide que Merge-Sort
Complexité en espace O(log n) si bien implémenté (récursif terminal,
en développant d’abord la partition la plus petite)

Jusqu’ici


QuickSort Θ(n2 ) Θ(n log n) Θ(n log n) oui
?? Θ(n log n) oui

Tri par tas : introduction
Heapsort en anglais
inventé par Williams en 1964
basé sur une structure de donnée très utile, le tas
complexité bornée par Θ(n log n) (dans tous les cas)
tri en place
mise en oeuvre très simple
Suite du cours :
I Introduction aux arbres
I Tas
I Tri par tas

....
Arbres : définition ........
Stacks, Queues Vectors, Lists Trees
........ Définition : Un arbre (tree) T est un graphe dirigé (N, E ), où :

........ ........ ........ ........
I N est un ensemble de nœuds, et

Tree ADT I E Basic
⊂ Algorithms
N × N estBinary
un Trees
ensemble
Tree Datad’arcs,
Structures
possédant les propriétés suivantes :

e constitue un cas d’école pour l’étude de la récursion
I T est connexe et acyclique
I Si T n’est pas vide, alors il possède un nœud 2distingué appelé racine
(root node). Cette racine est unique.
I Pour tout arc (n1 , n2 ) ∈ E , le nœud n1 est Arbres
le parent de n2 .
I
Notions de La racine
base surdeles
T ne possède pas de parent.
arbres
I Les autres nœuds de T possèdent un et un seul parent.
st la racine de l’arbre
A
nt de D et E
B C
s enfants de B
ères (ou siblings) D E F G H
de I sont H, C, A I
sont des noeuds externes

Arbres : terminologie
.... ........
Si n2 est le parent de n1 , alors n1 est le fils (child) de n2 .
Deux nœuds n1 et n2 qui possèdent le même parent sont des frères

........ ........ ........ ........ ........
(siblings).
Un nœud qui possède au moins un fils est un nœud interne.
Tree ADT Basic Algorithms Binary Trees Tree Data Structures
e constitueUnunnœud externe
cas d’école pour (c’est-à-dire, non interne) est une feuille (leaf) de
l’étude de la récursion
l’arbre. 2
Un nœud n2 est un ancêtre (ancestor) d’un nœud n1 si n2 est le
parent de n1 ou un ancêtre du parent de n1 .Arbres
Un nœud
Notions de n 2 estsur
base un les
descendant
arbres d’un nœud n1 si n1 est un ancêtre de
n .
st la racine2de l’arbre
A
nt de D et E
B C
s enfants de B
de I sont H, C, A I
sontAlgorithmes
des noeudsde tri externes 139
....
Arbres : terminologie ........
........ Un chemin est une séquence de nœuds n1 , n2 , . . . , nm telle que

........ ........ ........ ........
pour tout i ∈ [1, m − 1], (ni , ni+1 ) est un arc de l’arbre.

Tree ADT Remarque : Il n’existe jamais de chemin reliant deux feuilles
Basic Algorithms Binary Trees Tree Data Structures
distinctes.
e constitue un cas d’école pour l’étude de la récursion
La hauteur (height) d’un nœud n est le nombre d’arcs d’un plus long
chemin de ce nœud vers une feuille. La hauteur2 de l’arbre est la
hauteur de sa racine.
La profondeur (depth) d’un nœud n est le nombre d’arcs sur le
Arbres
Notions de base sur les arbres

chemin qui le relie à la racine.
st la racine de l’arbre
A
nt de D et E
B C
s enfants de B
de I sont H, C, A I
sontAlgorithmes
des noeudsde tri externes 140
Arbre binaire
Un arbre ordonné est un arbre dans lequel les ensembles de fils de

chacun de ses nœuds sont ordonnés.
Un arbre binaire est un arbre ordonné possédant les propriétés
suivantes :
I Chacun de ses nœuds possède au plus deux fils.
I Chaque nœud fils est soit un fils gauche, soit un fils droit.
I Le fils gauche précède le fils droit dans l’ordre des fils d’un nœud.
Un arbre binaire entier ou propre (full or proper) est un arbre binaire
dans lequel tous les nœuds internes possèdent exactement deux fils.
Un arbre binaire parfait est un arbre binaire entier dans lequel toutes
les feuilles sont à la même profondeur.

Propriétés des arbres binaires entiers
A"
B" C"
H"
Le nombre de nœuds externes est égal au nombre de nœuds internes

plus 1.
Le nombre de nœuds interne est égal à n−1
2 , où n désigne le nombre
de nœuds.
Le nombre de nœuds à la profondeur (ou niveau) i est ≤ 2i .
La hauteur h de l’arbre est ≤ au nombre de nœuds internes.
Le lien entre hauteur et nombre de nœuds peut être résumé comme
suit :
n ∈ Ω(h) et n ∈ O(2h ) (ou h ∈ O(n) et h ∈ Ω(log n))
Tas : définition
Un arbre binaire complet est un arbre binaire tel que :
Si h dénote la hauteur de l’arbre :
I Pour tout i ∈ [0, h − 1], il y a exactement 2i nœuds à la profondeur i.
I Une feuille a une profondeur h ou h − 1.
I Les feuilles deLecture
6-2 profondeur maximale
Notes for Chapter (h) sont “tassées” sur la gauche.
6: Heapsort
Un tas binaire (binary heap) est un arbre binaire complet tel que :
Example
Chacun de ses nœuds est associé à une clé.
Of a max-heap. [Arcs above and below the array on the right go bet
La clé de chaqueand nœud est supérieure
children. ou égale àtocelle
There is no significance de an
whether sesarcfils
is drawn ab
(propriété d’ordrethedu tas).
array.]
1
16
2 3
14 10
4 5 6 7 1 2 3 4 5 6 7 8
8 7 9 3 16 14 10 8 7 9 3 2
8 9 10
2 4 1

Propriété d’un tas
Soit T un arbre binaire complet contenant n entrées et de hauteur
h:
I n est supérieur ou égal à la taille de l’arbre complet de hauteur h − 1
plus un, soit 2h−1+1 − 1 + 1 = 2h
I n est inférieurLecture
6-2
ou égal à la taille de l’arbre complet de hauteur h, soit
Notes for Chapter 6: Heapsort
2h+1 − 1
h
≤ n ≤ 2h+1 − 1
2Example ⇔ 2h ≤ n < 2h+1
⇔ hand
Of a max-heap. [Arcs above ≤ below
log2 nthe
< harray
+ 1on the right go bet
and children. There is no significance to whether an arc is drawn ab
the array.] ⇔ h = blog2 nc
1
16
2 3
14 10
4 5 6 7 1 2 3 4 5 6 7 8
8 7 9 3 16 14 10 8 7 9 3 2
8 9 10
2 4 1

Of a max-heap. [Arcs above and below the array on the right go between parents
and children. There is no significance to whether an arc is drawn above or below
Implémentation
the array.] par un tableau
1
16
2 3
14 10
4 5 6 7 1 2 3 4 5 6 7 8 9 10
8 7 9 3 16 14 10 8 7 9 3 2 4 1
8 9 10
2 4 1
Un tasHeap
peutproperty
être représenté de manière compacte à l’aide d’un tableau A.
La
! racine de l’abre
For max-heaps est leelement
(largest premier élément
at root), du tableau.
max-heap property: for all nodes i,
Parent(i)
excluding=
thebi/2c
root, AŒPARENT.i/! ! AŒi!.
! For min-heaps (smallest element at root), min-heap property: for all nodes i,
Left(i) = 2i
excluding the root, AŒPARENT.i/! " AŒi!.
Right(i) = 2i + 1
By induction and transitivity of ", the max-heap property guarantees that the max-
Propriété
imumd’ordre
elementdu
of atas : ∀i, A[Parent(i)]
max-heap ≥ A[i]
is at the root. Similar argument for min-heaps.
The heapsort algorithm we’ll show uses max-heaps.
Note: In general, heaps can be k-ary tree instead of binary.
Principe du tri par tas
Lecture Notes for Chapter 6: Heapsort
Lecture Notes for Chapter 6: Heapsort
On construit un tas à partir du tableau à trier →
Build-max-heap(A).
Example
Example
Tant que le tas
Of a max-heap. contient
[Arcs des
above and éléments
below the array: on the right go between parents
Of and
a max-heap.
Ichildren.
[Arcs
There
On extrait is above and below
no significance
l’élément au sommet the
duarray
to whether on
arc the
tasanqu’on right dans
is place
drawn go between
above belowparents
or tableau
le
andthe
children. There is no significance to whether an arc is drawn above or below
mplémentation
array.]
par
trié et on
the array.] un
le remplace
1
tableau
par l’élément le plus à droite
116
2 3
16
14 10
2 3
4 5 6 7 1 2 3 4 5 6 7 8 9 10
14 10
8 7 9 3 16 14 10 8 7 9 3 2 4 1
4 5 6 7 1 2 3 4 5 6 7 8 9 10
8 9 10
28 4 1 7 9 3 16 14 10 8 7 9 3 2 4 1
8 9 10
2
I
4
On rétablit
1
la propriété de tas en tenant compte du fait que les
Heap sous-arbres
property de droite et de gauche sont des tas →
Max-Heapify(A, 1)
For max-heaps (largest element at root), max-heap property: for all nodes i,
Un tas peut êtredans
représenté de manière
initial → compacte
en place) à l’aide d’un tableau A.
!
Heap
(Tout seproperty
fait le tableau
excluding the root, AŒPARENT.i/! ! AŒi!.
La
! racine de l’abre(smallest
For min-heaps
!
est leelement
premier élément
at root), du property:
min-heap tableau.for all nodes i,
For max-heaps (largest element at root), max-heap property: for all nodes 146
Algorithmes de tri i,
Max-Heapify
Procédure Max-Heapify(A, i) :
I Suppose que le sous-arbre de gauche du nœud i est un tas
I Suppose que le sous-arbre de droite du nœud i est un tas
I But : réarranger le tas pour maintenir la propriété d’ordre du tas
6.2 Maintaining the heap property 155
Ex : Max-Heapify(A, 2)
1 1
16 16
2 3 2 3
i 4 10 14 10
4 5 6 7 4 5 6 7
14 7 9 3 i 4 7 9 3
8 9 10 8 9 10
2 8 1 2 8 1
(a) (b)
1
16
2 3
14 10
4 5 6 7
8 7 9 3
8 9 10
i
2 4 1
(c)

Max-Heapify
Max-Heapify(A, i)
1 l = Left(i)
2 r = Right(i)
3 if l ≤ A. heap-size ∧ A[l] > A[i]
4 largest = l
5 else largest = i
6 if r ≤ A. heap-size ∧ A[r ] > A[largest]
7 largest = r
8 if largest 6= i
9 swap(A[i], A[largest])
10 Max-Heapify(A, largest)
Complexité ? La hauteur du nœud : T (n) = O(log n) (Transp. 144)

for i D bn=2c downto 1
M AX -H EAPIFY .A; i; n/
Construction d’un tas
[Parameter n replaces both attributes A:length and A:heap-size.]
Build-Max-Heap(A)
Example 1 A.heap-size = A. length
2 forfrom
Building a max-heap i =thebA.length/2c downto
following unsorted 1 in the first heap
array results
example.
3 Max-Heapify(A, i)
! i starts off as 5.
(Invariant : !chaque nœud
M AX -H i, i+1,.
EAPIFY . . , to
is applied n est la racine
subtrees rooted d’un tas)
at nodes (in order): 16, 2, 3, 1, 4.
1 2 3 4 5 6 7 8 9 10
A 4 1 3 2 16 9 10 14 8 7
1 1
4 16
2 3 2 3
1 3 14 10
4 5 6 7 4 5 6 7
2 i 16 9 10 8 7 9 3
8 9 10 8 9 10
14 8 7 2 4 1
La tableau initial est interprété comme un arbre binaire complet

Correctness
On tasse lesinvariant:
Loop nœuds internes de bas
At start of every en haut
iteration et deeach
of for loop, droite
node i àCgauche
1,
Algorithmes de tri i C 2, . . . , n is root of a max-heap. 149
Complexité de Build-Max-Heap
Borne simple :
I O(n) appels à Max-Heapify, chacun étant O(log n) ⇒ O(n log n).
Analyse plus fine :

I Pour simplifier l’analyse, on suppose que l’arbre binaire est parfait.
I On a donc n = 2h+1 − 1 pour un h ≥ 0, qui est aussi la hauteur de
l’arbre résultant

h prof. noeuds
* 4 0 1
* * 3 1 2
* * * * 2 2 4
* * * * * * * * 1 3 8
0 4 16
* Noeuds sur lesquels on doit appeler Max-Heapify
Il y a 2i nœuds à la profondeur i (= hauteur h − i).

On doit appeler Max-Heapify sur chacun d’eux ⇒ O(h − i).
Nombre d’opérations en fonction de h :
h−1
X Xh−1
T (h) = 2i O(h − i) = O( 2i (h − i))
i=0 i=0
Ph−1
i=0 2i (h − i) = 1 · 2h−1 + 2 · 2h−2 + . . . + (h − 1) · 21 + h · 20
2h−1 + 2h−2 + 2h − 3 + ... + 20 = 2h − 1

+ 2h−2 + 2h − 3 + ... + 20 = 2h−1 − 1
+ 2h − 3 + ... + 20 = 2h−2 − 1
... ...
20 = 21 − 1

Ph
= i=1 2i − h
Pn i x n+1 −1
(En utilisant i=0 x = x−1 )
On obtient donc T (h) = O(2h+1 − h − 2).

Puisque h = log2 (n + 1) − 1 = O(log n), on a
T (n) = O(n).

Tri par tas : algorithme
Heap-Sort(A)
1 Build-Max-Heap(A)
2 for i = A.length downto 2
3 swap(A[i], A[1])
4 A.heap-size = A.heap-size − 1
5 Max-Heapify(A, 1)
Invariant :
A[1 . . i] est un tas contenant les i éléments les plus petits de A[1 . . A.length] et
A[i + 1 . . A.length] contient les n − i éléments les plus grands de
A[1 . . A. length] triés.

Tri par tas : illustration
Example
Tableau initial : Sort
A =an[7, 4, 3, 1,
example 2] on the board. [Nodes with heavy outline are no longer i
heap
heap.]
7 4
4 3 2 3
1 2 1 i 7
(a) (b)
3 2
2 1 1 3 i
i 4 7 4 7
(c) (d)
i 2 3
A 1 2 3 4 7
4 7
(e)
Analysis
Complexité de Heap-Sort
Heap-Sort(A)
1 Build-Max-Heap(A)
2 for i = A. length downto 2
3 swap(A[i], A[1])
4 A. heap-size = A. heap-size − 1
5 Max-Heapify(A, 1)
Build-Max-Heap : O(n)
Boucle for : n − 1 fois
Echange d’éléments : O(1)
Max-Heapify : O(log n)
Total : O(n log n) (pour le pire cas et le cas moyen)
Le tri par tas est cependant généralement battu par le tri rapide

Résumé


Quick-Sort Θ(n2 ) Θ(n log n) Θ(n log n) oui
Heap-Sort Θ(n log n) Θ(n log n) Θ(n log n)∗ oui
∗
pas montré dans ce cours

Peut-on faire mieux que O(n log n) ?
Non, si on se restreint aux tri comparatifs, c’est-à-dire :

I Aucune hypothèse sur les éléments à trier
I Nécessité de les comparer entre eux
Complexité d’un problème algorithmique versus complexité d’un
algorithme
Dans ce cas, un algorithme de tri est :
I Une suite de comparaisons d’éléments suivant une certaine méthode
I Un processus qui transforme un tableau [e0 , e1 , . . . , en−1 ] en un autre
tableau [eσ0 , eσ1 , . . . , eσn−1 ] où (σ0 , σ1 , . . . , σn−1 ) est une permutation
de (0, 1, . . . , n − 1).

Arbre de décision : exemple
Un algorithme de tri = un arbre binaire de décision (entier)
a1 ?a2
 >
a1 ?a3
a2 ?a3
 >
 >
a2 a1 a3 a2 ?a3
a1 ?a3
a1 a2 a3  >
 > a3 a2 a1
a2 a3 a1
a1 a3 a2 a3 a1 a2
(arbre de décision pour le tri par insertion du tableau [e0 , e1 , e2 ])
Exercice : construire l’arbre pour le tri par fusion

Arbre de décision : définition
Un algorithme de tri = un arbre binaire de décision

feuille de l’arbre : une permutation des éléments du tableau initial
tri : le chemin de la racine à la feuille correspondant au tableau trié
hauteur de l’arbre : le pire cas pour le tri
branche la plus courte : le meilleur cas pour le tri
hauteur moyenne de l’arbre : la complexité en moyenne du tri

Arbre de décision : propriété
Un arbre binaire de hauteur h a au plus 2h feuilles (cf transp. 142)
Le nombre de feuilles de l’arbre de décision est exactement n! où n
est la taille du tableau à trier
(par l’absurde : si moins que n! certains tableaux ne seraient pas
correctement triés)
On a donc :
n! ≤ 2h ⇒ log(n!) ≤ h
Formule de Stirling :
√ n 1 n
n! = 2πn( )n (1 + Θ( )) ⇒ n! ≥ ( )n
e n e
n
h ≥ log(n!) > log(( )n ) = n log n − n log e ⇒ h = Ω(n log n)
e
Le problème du tri comparatif est Ω(n log n)

Ce qu’on a vu
Catégorisation des algorithmes de tri

QuickSort (tri en place en O(n log n))
Analyse du cas moyen d’un algorithme
Notre première structure de données : le tas
HeapSort (tri en place en Θ(n log n))
Borne inférieure sur les tris comparatifs
Illustration :
I http://www.sorting-algorithms.com/

Ce qu’on n’a pas vu
Analyse formelle de la complexité moyenne du QuickSort.

Invariant pour le tri par tas
Méthodes de tri linéaire
Méthodes de sélection : trouver l’élément de rang i

Partie 4
Structures de données élémentaires
Structures de données élémentaires 163

Plan
1. Introduction
2. Pile
3. Files simple et double
4. Liste
5. Vecteur
6. File à priorité

Concept
Une structure de données est une manière d’organiser et de stocker

l’information
I Pour en faciliter l’accès ou dans d’autres buts
Une structure de données a une interface qui consiste en un
ensemble de procédures pour ajouter, effacer, accéder, réorganiser,
etc. les données.
Une structure de données conserve des données et éventuellement
des méta-données
I Par exemple : un tas utilise un tableau pour stocker les clés et une
variable A.heap-size pour retenir le nombre d’éléments qui sont dans
le tas.
Un type de données abstrait (TDA) = définition des propriétés de la
structure et de son interface (“cahier des charges”)

Structures de données
Dans ce cours :
Principalement des ensembles dynamiques (dynamic sets), amenés à
croı̂tre, se rétrécir et à changer au cours du temps.
Les objets de ces ensembles comportent des attributs.
Un de ces attributs est une clé qui permet d’identifier l’objet, les
autres attributs sont la plupart du temps non pertinents pour
l’implémentation de la structure.
Certains ensembles supposent qu’il existe un ordre total entre les
clés.

Opérations standards sur les structures
Deux types : opérations de recherche/accès aux données et

opérations de modifications
Recherche : exemples :
I Search(S, k) : retourne un pointeur x vers un élément dans S tel
que x.key = k, ou NIL si un tel élément n’appartient pas à S.
I Minimum(S), Maximum(S) : retourne un pointeur vers l’élément
avec la plus petite (resp. grande) clé.
I Successor(S, x),Predecessor(S, x) retourne un pointeur vers
l’élément tout juste plus grand (resp. petit) que x dans S, NIL si x
est le maximum (resp. minimum).
Modification : exemples :
I Insert(S, x) : insère l’élément x dans S.
I Delete(S, x) : retire l’élément x de S.

Implémentation d’une structure de données
Etant donné un TDA (interface), plusieurs implémentations sont

généralement possibles
La complexité des opérations dépend de l’implémentation, pas du
TDA.
Les briques de base pour implémenter une structure de données

dépendent du langage d’implémentation
I Dans ce cours, les principaux outils du C : tableaux, structures à la C
(objets avec attributs), liste liées (simples, doubles, circulaires), etc.
Une structure de données peut être implémentée à l’aide d’une autre
structure de données (de base ou non)

Quelques structures de données standards
Pile : collection d’objets accessible selon une politique LIFO

File : collection d’objets accessible selon une politique FIFO
File double : combine accès LIFO et FIFO
Liste : collection d’objets ordonnés accessible à partir de leur position
Vecteur : collection d’objets ordonnés accessible à partir de leur rang
File à priorité : accès uniquement à l’élément de clé (priorité)
maximale
Dictionnaire : structure qui implémente les 3 opérations recherche,

insertion, suppression (cf. partie 5)

Pile
Ensemble dynamique d’objets accessibles selon une discipline LIFO

(“Last-in first-out”).
Interface
I Stack-Empty(S) renvoie vrai si et seulement si la pile est vide
I Push(S, x) pousse la valeur x sur la pile S
I Pop(S) extrait et renvoie la valeur sur le sommet de la pile S
Applications :
I Option ’undo’ dans un traitement de texte
I Langage postscript
I Appel de fonctions dans un compilateur
I ...
Implémentations :
I avec un tableau (taille fixée a priori)
I au moyen d’une liste liée (allouée de manière dynamique)
I ...

Implémentation par un tableau
S est un tableau qui contient les éléments de la pile

S.top est la position courante de l’élément au sommet de S
Implémentation par un tableau
4 9 5
S est un tableau qui contientStack-Empty(S)
les éléments de la pile
1 de
S.top est la position courante return S.top ==
l’élément au 0sommet de
Pop(S)
Stack-Empty(S)
Push(S, x)
11 ifif S.top
Stack-Empty(S)
== 0
1 if S.top == S. length 2 error “underflow”
2 error “overflow” 2 return true
3 S. top = S.top + 1 33 else
else return
S. top = S. top − 1
false
4 return S[top(S) + 1]
4 S[S. top] = x
ComplexitéPush(S,
en temps x) et en espace : O(1) Pop(S)
(Inconvénient : L’espace occupé
1 S.top = S.top + 1 ne dépend pas du nombre d’objets)
1 if Stack-Emp
2 S[S.top] = x 2 error “und
3 else S.top = S
10.2 Linked lists 237
Rappel : liste simplement et doublement liée
prev key next
(a) L:head 9 16 4 1
(b) L:head 25 9 16 4 1
Structure de données composée d’une séquence d’éléments de liste.
Chaque
(c) élément x de25 la liste est9 composé16:
L:head 1
I d’un contenu utile x.data de type arbitraire (par exemple une clé),
I d’un pointeur
Figure 10.3 x. (a)next vers
A doubly l’élément
linked suivant
list L representing dansset la
the dynamic séquence
f1; 4; 9; 16g. Each element in
the list is an object with attributes for the key and pointers (shown by arrows) to the next and previous
I Doublement liée : d’une pointeur x. prev vers l’élément précédent
objects. The next attribute of the tail and the pre! attribute of the head are NIL , indicated by a diagonal
dans laslash.
séquence
The attribute L: head points to the head. (b) Following the execution of L IST-I NSERT.L; x/,
where x: key D 25, the linked list has a new object with key 25 as the new head. This new object
Soit L unepoints
listeto the
liée
old head with key 9. (c) The result of the subsequent call L IST-D ELETE.L; x/, where x
points to the object with key 4.
I L. head pointe vers le premier élément de la liste
I Doublement
elements.liée : L.tail
In the pointe
remainder of this vers le we
section, dernier
assumeélément dewith
that the lists la which
liste we
Le dernier are working are
élément unsorted un
possède and doubly linked.x.next vide (noté NIL)
pointeur
Doublement liée : aLe
Searching premier
linked list élément possède un pointeur x.prev
vide The procedure L IST-S EARCH .L; k/ finds the first element with key k in list L
by a simple linear search, returning a pointer to this element. If no object with
key k appears in the list, then the procedure returns NIL. For the linked list in
Figure 10.3(a), the call L IST-S EARCH .L; 4/ returns a pointer to the third element,
ecution of L IST-I NSERT.L; x/,
heImplémentation
new head. This newd’uneobject pile à l’aide d’une liste liée
L IST-D ELETE.L; x/, where x
S est une liste simplement liée (S.head pointe vers le premier
à l’aide d’une liste liée
élément de la liste)
ément dewith
at the lists la which
liste we Stack-Empty(S)
liée (S.head pointe
9 vers le14premier 1 if S. head = = NIL
de (noté NIL) 2 return true
3 else return false
pointeur x.prev
ack-Empty(S)
4
Pop(S)
ment with key
if S.head k in list L
== NIL 1 if Stack-Empty(S)
Push(S, x)
ement. If no object with
return true 2 error “underflow”
3 else x = S.head
1 x.next = S.head
IL . For
else the false
return linked list in
2 S.head = x 4 S. head = S. head.next
inter to the third element, 65 5 return x
Complexité en temps O(1), complexité en espace O(n) pour n

Pop(S)
opérations
1 if Stack-Empty(S)
2
error “underflow” 173
Application
Vérifier l’appariement de parenthèses ([],() ou {}) dans une chaı̂ne
de caractères
I Exemples : ((x) + (y )]/2 → non, [−(b) + sqrt(4 ∗ (a) ∗ c)]/(2 ∗ a) →
oui
Solution basée sur une pile :
ParenthesesMatch(A)
1 S = pile vide
2 for i = 1 to A. length
3 if A[i] est une parenthèse gauche
4 Push(S, A[i])
5 elseif A[i] est une parenthèse droite
6 if Stack-Empty(S)
7 return False
8 elseif Pop(S) n’est pas du même type que A[i]
9 return False
10 return Stack-Empty(S)

File
Ensemble dynamique d’objets accessibles selon une discipline FIFO

(“First-in first-out”).
Interface
I Enqueue(Q, s) ajoute l’élément x à la fin de la file Q
I Dequeue(Q) retire l’élément à la tête de la file Q
Implémentation à l’aide d’un tableau circulaire

I Q est un tableau de taille fixe Q. length
I Mettre plus de Q. length éléments dans la file provoque une erreur de
dépassement
I Q. head est la position à la tête de la file
I Q. tail est la première position vide à la fin de la file
I Initialement : Q.head = Q.tail = 1

Enqueue
234
234
etChapter
Dequeue
Chapter 10 Elementary Data Structures
10 Elementary Data Structures
234
Etat initial : Chapter 10 Elementary Data Structures
1 2 3 4 5 6 7 8 9 10 11 12
(a) Q 1 2 3 4 5 6 157 6 8 9 9 8 104 11 12
(a) Q 1 2 3 4 5 6 7 8 9 10 11 12
15 6 9 8 4
(a) Q Q:head D 7
15 6 9 8 4
Q:tail D 12
Q:head D 7 Q:tail D 12
1 2 3 4 5 6 7 8 9 10 11 12
Enqueue(Q, 17), Enqueue(Q, 3), Enqueue(Q,
Q:head D 7 5)Q:tail D 12
(b) Q 31 52 3 4 5 6
157 6 8 9 9 8 104 11
17 12
(b) Q 13 25 3 4 5 6 15 7 68 99 8
10 4
11 17
12
(b) Q 3 Q:tail
5 D 3 Q:head15D 76 9 8 4 17
1
2 3 D
Q:tail 4 3 5 Q:head
6 7 8 D 97 10 11 12
(c) Q 3 Q:tail
5 D3 15 6 D97 8 4 17
Q:head
1 2 3 4 5 6 7 8 9 10 11 12
Dequeue(Q) → 15
(c) Q 13 25 3 4 5 6 15
7 68 99 810 411 17
12
Q:tail D 3 Q:head D 8
(c) Q 3 5 15 6 9 8 4 17
Q:tail D 3 Q:head D 8
Figure 10.2 A queue implemented using an array QŒ1 : : 12!. Queue elements appear o
lightly shaded D 3 (a) TheQ:head
positions.
Q:tail queue hasD5 8elements, in locations QŒ7 : : 11!. (b) The con
of the queue after the calls E NQUEUE.Q; 17/, E NQUEUE.Q; 3/, and E NQUEUE.Q; 5/
Figure 10.2 ofA the
configuration queue implemented
queue using
after the call an array
D EQUEUE .Q/QŒ1returns theQueue
: : 12!. elements
key value ap
15 forme
lightly shaded
Structures de données élémentaires positions. (a) The queue has 5 elements, in locations QŒ7 : : 11!. (b)
176 T
Enqueue et Dequeue
Enqueue(Q,x) Dequeue(Q)
1 Q[Q. tail] = x 1 x = Q[Q. head]
2 if Q. tail = = Q. length 2 if Q.head == Q. length
3 Q. tail = 1 3 Q. head = 1
4 else Q. tail = Q.tail + 1 4 else Q. head = Q. head + 1
5 return x
Complexité en temps O(1), complexité en espace O(1).

Exercice : ajouter la gestion d’erreur

Soit la file double Q :
Implémentation à l’aide d’une liste liée
I Q.head pointe vers un
I Q.tail pointe vers un
Q.head pointe
I 9 vers un14 4
Q.tail pointe vers un
I
Q est une liste simplement liée

Q.head (resp. Q.tail) pointe vers la tête (resp. la queue) de la liste
Enqueue(Q,x) Dequeue(Q)
1 x. next = NIL 1 if Q.head = = NIL
2 if Q.head == NIL 2 error “underflow”
3 Q. head = x 3 x = Q. head
4 else Q. tail.next = x 4 Q. head = Q. head.next
5 Q. tail = x 5 if Q.head = = NIL
6 de données
Structures Q. tail = NIL
élémentaires
7 return x
Complexité en temps O(1), complexité en espace O(n) pour n
opérations

File double
Double ended-queue (deque)
Généralisation de la pile et de la file

Collection ordonnée d’objets offrant la possibilité
I d’insérer un nouvel objet avant le premier ou après le dernier
I d’extraire le premier ou le dernier objet
Interface :
I insert-first(Q, x) : ajoute x au début de la file double
I insert-last(Q, x) : ajoute x à la fin de la file double
I remove-first(Q) : extrait l’objet situé en première position
I remove-last(Q) : extrait l’objet situé en dernière position
I ...
Application : équilibrage de la charge d’un serveur

Implémentation par u
Implémentation à l’aide d’une liste doublement liée
mplémentation par une liste doublement liée
A l’aide d’une liste double liée
I Q.head pointe vers un élément sentinelle en début de liste
I Q.tail pointe vers un élément sentinelle en fin de Soit
liste la file double Q
I Q.size est la taille courante de la liste I Q.head pointe ver
I Q.tail pointe vers
I Q.head pointe vers un 9 14 4
I Q.tail pointe vers un
Les sentinelles ne contiennent pas de données. Elles permettent de
simplifier le code (pour un coût en espace constant).
Exercice : implémentation de la file double sans sentinelles,

implémentation de la file simple avec sentinelle
Structures de données élémentaires Structures de données élémentaires 180

insert-first(Q, x) insert-last(Q, x)
1 x. prev = Q. head 1 x.prev = Q. tail.prev
2 x. next = Q.head.next 2 x.next = Q. tail
3 Q. head.next.prev = x 3 Q. tail.prev .next = x
4 Q. head.next = x 4 Q. head.prev = x
5 Q. size = Q. size + 1 5 Q. size = Q. size + 1
remove-first(Q) remove-last(Q)
1 if (Q. size == 0) 1 if (Q. size == 0)
2 error 2 error
3 x = Q. head.next 3 x = Q.tail.prev
4 Q. head.next = Q.head.next.next 4 Q. tail.prev = Q. tail.prev .prev
5 Q. head.next.prev = Q. head 5 Q. tail.prev .next = Q. head
6 Q. size = Q. size − 1 6 Q. size = Q. size − 1
7 return x 7 return x
Complexité O(1) en temps et O(n) en espace pour n opérations.

Liste
Ensemble dynamique d’objets ordonnés accessibles relativement les
uns aux autres, sur base de leur position
Généralise toutes les structures vues précédemment
Interface :
I Les fonctions d’une liste double (insertion et retrait en début et fin de
liste)
I Insert-Before(L, p, x) : insére x avant p dans la liste
I Insert-After(L, p, x) : insère x après p dans la liste
I Remove(L, p) : retire l’élement à la position p
I replace(L, p, x) : remplace par l’objet x l’objet situé à la position p
I first(L), last(L) : renvoie la première, resp. dernière position dans
la liste
I prev(L, p), next(L, p) : renvoie la position précédant (resp. suivant)
p dans la liste
Implémentation similaire à la file double, à l’aide d’une liste

doublement liée (avec sentinelles)
mplémentation à l’aide d’une liste doublement liée
p.prev p.next p x 6 remove(L, p)
1 p.prev .next = p.next
Implémentation
Implémentation ààl’aide
p, x) d’une
l’aide
Implémentation d’une liste
liste2doublement
à l’aide doublement
d’une liste liée
p, x)doublement
insert-before(L,
9 14 4
insert-after(L,
p.next.prev = p.prev liée
1 x.prev = p.prev 1 x.prev = p = L.size − 1
3 L.size
p.prev
p.prev2p.next
x.nextp p=
p.next xp.prev
xp p.next p x 2 x.next = p.next
4 return p
3 p.prev .next = x 3 p.next.prev = x
4 insert-before(L,
insert-before(L,
p.prev =x insert-before(L,
p,p,x)x) p, x) = x
insert-after(L,
insert-after(L,
4 p.next insert-after(L,
p, x) p, x)
5 1L.size = L.size + 1
1 x. prev = p. prev 1 x. prev = p
x.x.
prev ==p.p.
1 insert-before(L,
prev prev
prev p, x) 5 L.size 11 x. x.=prev
L.size
prev
insert-after(L, =+
= pp 1 p, x)
2 x. next = p 2 x. next = p. next
2 2 x. next
x. next = =p p
1 x. prev = p.prev 22 x.
x. next
next =
= p.
p.next
3 p. prev .next = 1 x x.prev = p 3 p. next.prev = x
3 3 p.
2 p. prev
prev
x. .next
.next
next ==p=4xx p. prev 33 p. p.next.prev
next.prev = x
remove(L, p) = x 4 p. next = x
4 4 p.
3 p. prev
prev
p. prev x x 5 = L.x size = L. size24+
==.next 4 1x.next
p.next
p. next == xxp.next
= 5 L. size = L. size + 1
5 5 L. 1L.size
p.prev
++1.next = p.next355 p.next.prev =+ x1
4 L. size
size
p. ==L.
prev = size
x 1
2 p.next.prev = p.prev
L.size
L. size =
= L.L.size
5 L. size 3= L.size 4 p.next = x
L.size + = 1L.size 1
remove(L, p)
remove(L,
5 L.size = L.size + 1
p) 1 p. prev .next = p. next
4 return p
remove(L, p)
Complexité O(1) en temps et O(n)
11 p.p.prev
prev.nexten=
.next espace
2= nextpour n= opérations.
p.next
p. next.prev p. prev
Complexité O(1) en temps et O(n) en espace pour n opérations.1
2 2 p.
p. next.prev
next.prev 3
== L.
p.
p. size
prev
prev = L. size
33 L.L.size 4 return
size ==L.L.size
size 11 p
Vecteur
Ensemble dynamique d’objets occupant des rangs entiers successifs,

permettant la consultation, le remplacement, l’insertion et la
suppression d’éléments à des rangs arbitraires
Interface
I Elem-At-Rank(V , r ) retourne l’élément au rang r dans V .
I Replace-At-Rank(V , r , x) remplace l’élément situé au rang r par
x et retourne cet objet.
I Insert-At-Rank(V , r , x) insère l’élément x au rang r , en
augmentant le rang des objets suivants.
I Remove-At-Rank(V , r ) extrait l’élément situé au rang r et le
retire de r , en diminuant le rang des objets suivants.
I Vector-Size(V ) renvoie la taille du vecteur.
Applications : tableau dynamique, gestion des éléments d’un
menu,. . .
Implémentation : liste liée, tableau extensible. . .

Implémentation par un tableau extensible
Les éléments sont stockés dans un tableau extensible V .A de taille
initiale V .c.
En cas de dépassement, la capacité du tableau est doublée.
V .n retient le nombre de composantes.
Insertion et suppression :
Insert-At-Rank(V , r , x) Remove-At-Rank(V , r )
1 if V . n = = V . c 1 tmp = V . A[r ]
2 V .c = 2 · V .c 2 for i = r to V . n − 1
3 W = “Tableau de taille V . c” 3 V . A[i] = V . A[i + 1]
4 for i = 1 to n 4 V .n = V .n − 1
5 W [i] = V .A[i] 5 return tmp
6 V .A = W
7 for i = V . n downto r
8 V . A[i + 1] = V . A[i]
9 V . A[r ] = x
10 V . n = V . n + 1

Complexité en temps
Insert-At-Rank :
I O(n) pour une opération individuelle, où n est le nombre de
composantes du vecteur
I O(n2 ) pour n opérations d’insertion en début de vecteur
I O(n) pour n opérations d’insertion en fin de vecteur
Justification :
I Si la capacité du tableau passe de c0 à 2k c0 au cours des n
opérations, alors le coût des transferts entre tableaux s’élève à
c0 + 2c0 + . . . + 2k−1 c0 = (2k − 1)c0 .
Puisque 2k−1 c0 < n ≤ 2k c0 , ce coût est O(n).

I On dit que le coût amorti par opération est O(1)
I Si on avait élargi le tableau avec un incrément constant m, le coût
aurait été
k(k − 1)
c0 + (c0 + m) + (c0 + 2m) + . . . + (c0 + (k − 1)m) = kc0 + m.
2
Puisque c0 + (k − 1)m < n ≤ c0 + km, ce coût aurait donc été O(n2 ).
Complexité en temps
Remove-At-Rank :
I O(n) pour une opération individuelle, où n est le nombre de
composantes du vecteur
I O(n2 ) pour n opérations de retrait en début de vecteur
I O(n) pour n opérations de retrait en fin de vecteur
Remarque : Un tableau circulaire permettrait d’améliorer l’efficacité
des opérations d’ajout et de retrait en début de vecteur.

File à priorité
Ensemble dynamique d’objets classés par ordre de priorité

I Permet d’extraire un objet possédant la plus grande priorité
I En pratique, on représente les priorités par les clés
I Suppose un ordre total défini sur les clés
Interface :
I Insert(S, x) : insère l’élément x dans S.
I Maximum(S) : renvoie l’élément de S avec la plus grande clé.
I Extract-Max(S) : supprime et renvoie l’élément de S avec la plus
grande clé.
Remarques :
I Extraire l’élément de clé maximale ou minimale sont des problèmes
équivalents
I La file FIFO est une file à priorité où la clé correspond à l’ordre
d’arrivée des élements.
Application : gestion des jobs sur un ordinateur partagé

Implémentations
Implémentation à l’aide d’un tableau statique
I Q est un tableau statique de taille fixée Q. length.
I Les éléments de Q sont triés par ordre croissant de clés. Q. top pointe
vers le dernier élément.
I Complexité en temps : extraction en O(1) et insertion en O(n) où n
est la taille de la file
I Complexité en espace : O(1)
Implémentation à l’aide d’une liste liée
I Q est une liste liée où les éléments sont triés par ordre décroissant de
clés
I Complexité en temps : extraction en O(1) et insertion en O(n) où n
est la taille de la file
I Complexité en espace : O(n)
Exercice : comment obtenir O(1) pour l’insertion et O(n) pour
l’extraction ?
Implémentation à l’aide d’un tas
La file est implémentée à l’aide d’un tas(-max) (voir slide 143)

Accès et extraction du maximum :
Heap-Maximum(A) Heap-Extract-Max(A)
1 return A[1] 1 if A. heap-size < 1
2 error “heap underflow”
3 max = A[1]
4 A[1] = A[A. heap-size]
5 A.heap-size = A.heap-size − 1
6 Max-heapify(A, 1) // reconstruit le tas
7 return max
Complexité : O(1) et O(log n) respectivement (voir chapitre 3)

Of a max-heap. [Arcs above and below the array
Implémentation à l’aide d’un tas
and children. There is no significance to whether
the array.]
1
16
2 3
14 10
4 5 6 7 1 2
8 7 9 3 16 14
8 9 10
2 4 1
Heap property
Implémentation à l’aide d’un tas : insertion
Increase-Key(S, x, k) augmente la valeur de la clé de x à k (on

suppose que k ≥ à la valeur courante de la clé de x).
Heap-Increase-Key(A, i, key )
1 if key < A[i]
2 error “new key is smaller than current key”
3 A[i] = key
4 while i > 1 and A[Parent(i)] < A[i]
5 swap(A[i], A[Parent(i)])
6 i = Parent(i)
Complexité : O(log n) (la longueur de la branche de la racine à i

étant O(log n) pour un tas de taille n).

Implémentation à l’aide d’un tas : insertion
Pour insérer un élément avec une clé key :

I l’insérer à la dernière position sur le tas avec une clé −∞,
I augmenter sa clé de −∞ à key en utilisant la procédure précédente
Heap-Insert(A, key )
1 A. heap-size = A. heap-size + 1
2 A[A.heap-size] = −∞
3 Heap-Increase-Key(A, A. heap-size, key )
Complexité : O(log n).
⇒ Implémentation d’une file à priorité par un tas : O(log n) pour

l’extraction et l’insertion.

Ce qu’on a vu
Quelques structures de données classiques et différentes

implémentations pour chacune d’elles
I Pile
I Liste
I Files simples, doubles et à priorité
I Vecteurs
Structures de type liste liée

Ce qu’on n’a pas vu
Structure de type séquence : hybride entre le vecteur et la liste

Notion d’itérateur
Tas binomial : alternative au tas binaire qui permet la fusion rapide
de deux tas
Evolution dynamique de la taille d’un tas (analyse amortie)
...

Partie 5
Dictionnaires
Dictionnaires 196
Plan
1. Introduction
2. Arbres binaires de recherche
3. Tables de hachage
Dictionnaires 197
Dictionnaires
Définition : un dictionnaire est un ensemble dynamique d’objets avec

des clés comparables qui supportent les opérations suivantes :
I Search(S, k) retourne un pointeur x vers un élément dans S tel que
x. key = k, ou NIL si un tel élément n’appartient pas à S.
I Insert(S, x) insère l’élément x dans le dictionnaire S. Si un élément
de même clé se trouve déjà dans le dictionnaire, on met à jour sa
valeur
I Delete(S, x) retire l’élément x de S. Ne fait rien si l’élément n’est
pas dans le dictionnaire.
Pour faciliter la recherche, on peut supposer qu’il existe un ordre

total sur les clés.
Dictionnaires 198
Dictionnaires
Deux objectifs en général :

I minimiser le coût pour l’insertion et l’accès au données
I minimiser l’espace mémoire pour le stockage des données
Exemples d’applications :
I Table de symboles dans un compilateur
I Table de routage d’un DNS
I ...
Beaucoup d’implémentations possibles
Dictionnaires 199
Liste liée
Première solution :
On stocke les paires clé-valeur dans une liste liée
Recherche :
List-Search(L, k)
1 x = L. head
2 while x 6= NIL ∧ x. key 6= k
3 x = x. next
4 return x
Insertion (resp. Suppression)

I On recherche la clé dans la liste
I Si elle existe, on remplace la valeur (resp. on la supprime)
I Si elle n’existe pas, on la place en début de liste (resp. on ne fait rien)
Complexité au pire cas (meilleur cas ?)
I Insertion : O(N)
I Recherche : O(N)
I Suppression : O(N)
Dictionnaires 200
Vecteur trié
Deuxième solution :
On suppose qu’il existe un ordre total sur les clés
On stocke les éléments dans un vecteur qu’on maintient trié
Recherche dichotomique (approche “diviser-pour-régner”)
Binary-Search(V , k, low , high)
1 if low > high
2 return NIL
3 mid = b(low + high)/2c
4 x = Elem-At-Rank(V , mid)
5 if k == x.key
6 return x
7 elseif k > x.key
8 return Binary-Search(V , k, mid + 1, high)
9 else return Binary-Search(V , k, low , mid − 1)
Complexité : O(log n)
Dictionnaires 201
Vecteur trié
Insertion : recherche de la position par Binary-Search puis

insertion dans le vecteur par Insert-At-Rank (=décalage des
éléments vers la droite).
Suppression : recherche puis suppression par Remove-At-Rank
(=décalage des éléments vers la gauche).
Complexité au pire cas (meilleur cas ?)
I Insertion : O(N) (on doit décaler les éléments à droite de la clé)
I Recherche : O(log N) (recherche dichotomique)
I Suppression : O(N) (on doit décaler les éléments à gauche de la clé)
(Si le vecteur est implémenté par un tableau extensible !)
Dictionnaires 202
Dictionnaires : jusqu’ici
Pire cas En moyenne

Implémentation Search Insert Delete Search Insert Delete
Liste Θ(n) Θ(n) Θ(n) Θ(n) Θ(n) Θ(n)

Vecteur trié Θ(log n) Θ(n) Θ(n) Θ(log n) Θ(n) Θ(n)
Peut-on obtenir à la fois une insertion et une recherche “efficace” ?
Dictionnaires 203
Plan
1. Introduction

Type de données abstrait pour un arbre
Arbre binaire de recherche
Arbres équilibrés AVL
Principe
Fonctions de hachage
Adressage ouvert
Comparaisons
Dictionnaires 204
Principe :
I Des données sont associées aux nœuds d’un arbre
I Les nœuds sont accessibles les uns par rapport aux autres selon leur
position dans l’arbre
Interface : Pour un arbre T et un noeud n
I Parent(T , n) : renvoie le parent d’un noeud n (signale une erreur si
n est la racine)
I Children(T , n) : renvoie une structure de données (ordonnée ou
non) contenant les fils du nœud n (exemple : une liste)
I isRoot(T , n) : renvoie vrai si n est la racine de l’arbre
I isInternal(T , n) : renvoie vrai si n est un nœud interne
I isExternal(T , n) : renvoie vrai si n est un nœud externe
I GetData(T , n) : renvoie les données associées au nœud n
I Left(T , n), Right(T , n) : renvoie les fils gauche et droit de n (pour
un arbre binaire)
I Root(T ) : renvoie le nœud racine de l’arbre
I Size(T ) : renvoie le nombre de nœuds de l’arbre
I ...
Dictionnaires 205
Exemples d’opération sur un arbre
Calcul de la profondeur d’un nœud
Depth-rec(T , n)
1 if isRoot(T , n)
2 return 0
3 return 1 + Depth-rec(T , Parent(T , n))
Version itérative
Depth-iter(T , n)
1 d =0
2 while not isRoot(T , n)
3 d = d +1
4 n = Parent(T , n)
5 return d
Complexité en temps : O(n), où n est la taille de l’arbre (si les

opérations de l’interface sont O(1))
Dictionnaires 206
Exemples d’opération sur un arbre
Calcul de la hauteur de l’arbre

Height(T , n)
1 if isExternal(T , n)
2 return 0
3 h=0
4 for each n2 in Children(T , n)
5 h = max(h, Height(T , n2))
6 return h + 1
Complexité en temps : O(n), où n est la taille de l’arbre (si les

opérations de l’interface sont O(1))
Dictionnaires 207
Implémentation d’un arbre binaire
Première solution : numérotation de niveaux

L’arbre est représenté par un vecteur (ou un tableau)
Chaque position dans l’arbre est associé à un rang particulier :
I La racine est en position 1
I Si un nœud est au rang r , son successeur gauche est au rang 2r , son
successeur droit au rang 2r + 1
Si l’arbre binaire n’est pas un arbre binaire complet, le vecteur
contiendra des trous (qu’il faudra pouvoir identifier)
Complexité en temps des opérations : O(1)
Complexité en espace : O(2n ) pour un arbre de n nœuds (Θ(n) pour
un arbre binaire complet)
Dictionnaires 208
Implémentation d’un arbre binaire
Deuxième solution : structure liée

Principe : on retient pour chaque nœud n de l’arbre :
I Un champ de données (n. data)
I Un pointeur vers son nœud parent (n. parent)
I Un pointeur vers ses fils gauche et droit (n. left et n. right)
Complexité en temps des opérations : O(1)
Complexité en espace : Θ(n) pour n nœuds
(généralise la notion de liste liée)
Dictionnaires 209
Implémentation d’un arbre quelconque
Même structure liée que pour un arbre binaire
Mais on remplace n.left et n.right par un pointeur n.children vers
un ensemble dynamique
Le type d’ensemble dynamique (vecteur, liste, . . . ) dépendra des
opérations devant être effectuées
children parent nextchild
6 6
9 14 4
9 14 4
5 3
5 3
(on peut aussi représenter un arbre quelconque par un arbre binaire)
Dictionnaires 210
Implémentation des arbres binairesBinary Search Tree (2)
Implementation
! T represents the tree, which consists of a set of nodes
Implémentation des arbres binaires dans le reste de ce cours :
! T . root is the root node of tree T
T représente l’arbre, qui consiste en un
Node x
ensemble de nœuds x.parent
! x. parent is the parent of node x
T .root est le nœud racine de l’arbre T
! x. key is the key stored in node x
node x
Nœud x ! x. left is the left child of node x k k = x.key
I x. parent est !le x.parent
right isdu
thenœud x of node x
right child
I x. key est la clé stockée au nœud x
I x. left est le fils de gauche du nœud x x.left x.right
I x. right est le fils de droite du nœud x
Pour simplifier les notations, nos fonctions seront implémentées

directement sur base de cette implémentation (et pas de l’interface
© 2006 Antonio Carzaniga 4
générale)
Dictionnaires 211
Parcours d’arbres (binaire)
Un parcours d’arbre est une façon d’ordonner les nœuds d’un arbre
afin de les parcourir
Différents types de parcours :
I Parcours en profondeur :
I Infixe (en ordre)
I Préfixe (en préordre)
I Suffixe (en postordre)
I Parcours en largeur
Dictionnaires 212
[This is Figure 12.1(a) from the text, using A, B , D , F , H , K in place of
Parcours infixe 5, 7, 8, with alphabetic comparisons. It’s OK to have duplicate keys, thou
are none in this example. Show that the binary-search-tree property holds.
F
B H
A D K
The binary-search-tree property allows us to print keys in a binary search

order, ⇒ hA, B, using
recursively, D, F an
, H, K i called an inorder tree walk. Elem
algorithm
printed in monotonically increasing order.
How I NORDER -T REE -WALK works:
Parcours infixe (en ordre) : Chaque nœud est visité après son fils
! Check to make sure that x is not NIL.
gauche et avant son fils droit
! Recursively, print the keys of the nodes in x’s left subtree.
! Print x’s key.
Inorder-Tree-Walk(x)
! Recursively, print the keys of the nodes in x’s right subtree.
1I NORDER
if x 6=-TNIL
REE -WALK .x/
2 if x ¤ Inorder-Tree-Walk(x.
NIL
left)
3 print x.key
I NORDER -T REE -WALK .x:left/
4 Inorder-Tree-Walk(x.
print keyŒx! right)
I NORDER -T REE -WALK .x:right/
Dictionnaires 213
[This is Figure 12.1(a) from the text, using A, B , D , F , H , K in
5, 7, 8, with alphabetic comparisons. It’s OK to have duplicate ke
Parcours préfixeare none in this example. Show that the binary-search-tree proper
F
B H
A D K
The binary-search-tree property allows us to print keys in a bina

⇒ hF , B,using
order, recursively, A, D,an
H,algorithm
Ki called an inorder tree wa
Parcours préfixe
How(en préordre)
I NORDER : chaque
-T REE -WALKnœud
works:est visité avant ses fils
! Preorder-Tree-Walk(x)
Recursively, print the keys of the nodes in x’s left subtree.
! 1 Print
if x x’s
6= NIL
key.
2 print x. key
! Recursively, print the keys of the nodes in x’s right subtree.
3 Preorder-Tree-Walk(x.left)
I NORDERPreorder-Tree-Walk(x.right)
4 -T REE -WALK .x/
if x ¤ NIL
Dictionnaires 214
5, 7, 8, with alphabetic comparisons. It’s OK to have duplicate ke
Parcours postfixe
are none in this example. Show that the binary-search-tree proper
F
B H
A D K
The binary-search-tree property allows us to print keys in a bina

⇒ hA, D, B, K , H, F i
order, recursively, using an algorithm called an inorder tree wa
Parcours postfixe (en postordre) : chaque nœud est visité après ses
How I NORDER -T REE -WALK works:
fils
! Recursively, print the keys of the nodes in x’s left subtree.
Postorder-Tree-Walk(x)
!
1 Print
if x 6=
x’sNIL
key.
!2 Recursively,
Postorder-Tree-Walk(x. left)
print the keys of the nodes in x’s right subtree.
3 Postorder-Tree-Walk(x. right)
I4NORDERprint x.-W
-T REE keyALK .x/
if x ¤ NIL
Dictionnaires 215
Complexité des parcours
Tous les parcours en profondeur sont Θ(n) en temps

Soit T (n) le nombre d’opérations pour un arbre avec n nœuds
On a T (n) = Ω(n) (on doit au moins parcourir chaque nœud).
Etant donné la récurrence, on a :
T (n) ≤ T (nL ) + T (n − nL − 1) + d
où nL est le nombre de nœuds du sous-arbre à gauche et d une

constante
On peut prouver par induction que T (n) < (c + d)n + c où
c = T (0).
T (n) = Ω(n) et T (n) = O(n) ⇒ T (n) = Θ(n)
Dictionnaires 216
Parcours
!
en largeur
Stored keys must satisfy the binary-search-tree property.
Parcours
If y is inen
! leftlargeur
subtree :ofonx,visite le nœud
then y:key le plus proche de la racine
! x:key.
qui
If yn’a
! pasright
is in déjàsubtree
été visité. Correspond
of x, then à une visite de nœud de
y:key " x:key.
profondeur
Draw sample tree.
1, puis 2, . . . .
Implémentation à l’aide d’une file en Θ(n)
[This is Figure 12.1(a) from the text, using A, B , D , F , H , K in place of 2, 3, 5,
5, 7, 8, with alphabetic comparisons. It’s OK to have duplicate keys, though there
are none in this example. Show that the binary-search-tree property holds.]
Breadth-Tree-Walk(x)
F 1 Q = ”Empty queue”
2 Enqueue(Q, x)
B H 3 while not Queue-Empty(Q)
4 y = Dequeue(Q)
A D K 5 print y .key
6 if y .left 6= NIL
7 Enqueue(Q, y .left)
The binary-search-tree property allows us to print keys
if in a binary search tree in
6= NIL
⇒ hF , B, H, A, D, K i 8
order, recursively, using an algorithm called an inorder
y .right
tree walk. Elements
9 Enqueue(Q, y .right)are
(Exercice : Implémenter
How I NORDER les parcours
-T REE -WALK works: en profondeur de manière non
récursive)
Dictionnaires 217
Plan
1. Introduction

Principe
Adressage ouvert
Comparaisons
Dictionnaires 218
Arbres binaires de recherche
Une structure d’arbre binaire implémentant un dictionnaire, avec des
opérations en O(h) où h est la hauteur de l’arbre
Chaque nœud de l’arbre binaire est associé à une clé

L’arbre satisfait à la propriété d’arbre binaire de recherche
I Soient deux nœuds x et y .
I Si y est dans le sous-arbre de gauche de x, alors y .key < x.key
12.1 What is a binary search tree? 287
I Si y est dans le sous-arbre de droite de x, alors y .key ≥ x.key
6 2
5 7 5
2 5 8 7
6 8
(a) (b)
Dictionnaires 219
Parcours d’un arbre
12.1 binaire desearch
What is a binary recherche
tree?
6 2
5 7 5
2 5 8 7
6 8
⇒ h2, 5, 5, 6, 7, 8i
5
(a) (b)
Le parcours infixe d’un arbre binaire de recherche permet d’afficher
les clés par ordre croissant
Figure 12.1 Binary search trees. For any node x, the keys in the left subtree of x are at m
and the keys in the right subtree of x are at least x: key. Different binary search trees can
the same set of values. The worst-case running time for most search-tree operations is pro
Inorder-Tree-Walk(x)
to the height of the tree. (a) A binary search tree on 6 nodes with height 2. (b) A less efficie
search tree with height 4 that contains the same keys.
1 if x 6= NIL
2 Inorder-Tree-Walk(x. left)
its right child, and its parent, respectively. If a child or the parent is miss
3 appropriate
print x.key
attribute contains the value NIL. The root node is the only nod
4 tree whose
Inorder-Tree-Walk(x.
parent is NIL. right)
The keys in a binary search tree are always stored in such a way as to sa
Dictionnaires binary-search-tree property: 220
Recherche dans un arbre binaire
Recherche binaire
Tree-Search(x, k)
1 if x == NIL or k == x.key
2 return x
3 if k < x. key
4 return Tree-Search(x.left, k)
5 else return Tree-Search(x. right, k)
Appel initial (à partir d’un arbre T )

Tree-Search(T .root, k)
Complexité ? T (n) = O(h), où h est la hauteur de l’arbre

Pire cas : h = n
Dictionnaires 221
Recherche dans un arbre binaire
Tree-Search est récursive terminale.

Version itérative
Iterative-Tree-Search(T , k)
1 x = T .root
2 while x 6= NIL and k 6= x. key
3 if k < x. key
4 x = x.left
5 else x = x.right
6 return x
Dictionnaires 222
Clés maximale et minimale
Etant donné la propriété d’arbre binaire

I La clé minimale se trouve dans le nœud le plus à gauche
I La clé maximale se trouve dans le noœud le plus à droite
Tree-Minimum(x) Tree-Maximum(x)
1 while x.left 6= NIL 1 while x.right 6= NIL
2 x = x.left 2 x = x.right
3 return x 3 return x
Complexité : O(h), où h est la hauteur de l’arbre.
Dictionnaires 223
Successeur et prédécesseur
T REE -P REDECESSOR is symmetric to T REE -S UCCESSOR.
Etant donné un nœud x, trouver le nœud contenant la valeur de clé
suivante (dans l’ordre)
Example
15
6 18
3 7 17 20
2 4 13
Find the successor

Ex : successeur
! of the
de 15 → 17, node with
successeur de key
4 →value
6. 15. (Answ
Le successeur deFind
x estthele successor
minimum ofduthe node with
sous-arbre dekey value
droite s’il6.existe
(Answe
!
Sinon, c’est le premier

! Find theancêtre a deofx the
successor tel node
que xwith
tombekeydans
valuele4. (Answe
sous-arbre de gauche
! de a.
Find the predecessor of the node with key value 6. (Answ
Dictionnaires 224
y D x:p
while y ¤ NIL and x == y:right
Successeur et prédécesseur x Dy
y D y:p
return y
T REE -P REDECESSOR is symmetric to T REE -S UCCE
Example
Tree-Successor(x)
15
1 if x. right 6= NIL
2 return Tree-Minimum(x. right) 6 18
3 y = x. parent
4 while y 6= NIL and x == y . right 3 7 17 20
5 x =y
2 4 13
6 y = y .parent
7 return y 9
! Find the successor of the node with key value 15

Complexité : O(h), où h est la hauteur de Find
l’arbre
!the successor of the node with key value 6.
! Find the successor of the node with key value 4.
(Exercice : Tree-Predecessor) ! Find the predecessor of the node with key value 6
Time
For both the T REE -S UCCESSOR and T REE -P REDE
cases, we visit nodes on a path down the tree or up t
Dictionnaires 225
Insertion 12.3 Insertion and deletion
12
5 18
2 9 15 19
13 17
Pour insérer
Figure x, 12.3
on recherche
Insertingla an
cléitem
x.key dans
with keyl’arbre
13 into a binary search t
Si on nethe la simple path on
trouve pas, from the root
l’ajoute down to
à l’endroit oùthe position where
la recherche s’est the i
arrêtée. indicates the link in the tree that is added to insert the item.
Dictionnaires 226
Insertion
12.3 Insertion and deletion

Tree-Insert(T , z)
1 y = NIL
12
2 x = T .root
3 while x 6= nil
5 18
4 y =x
5 if z. key < x. key 2 9 15 19
6 x = x.left
7 else x = x.right 13 17
8 z. parent = y
9 if y = = NIL Figure 12.3 Inserting an item with key 13 into a binary se
10 // Tree T was empty the simple path from the root down to the position where
11 T . root = z indicates the link in the tree that is added to insert the item.
Complexité : O(h) où h est la
12 elseif z.key < y . key
13 y . left = z
hauteur de l’arbre
Figure 12.3 shows how T REE -I NSERT works.
S EARCH and I TERATIVE -T REE -S EARCH, T REE
14 else y . right = z tree and the pointer x traces a simple path downw
with the input item ´. The procedure maintains th
of x. After initialization, the while loop in line
to move down the tree, going left or right depen
Dictionnaires 227
If ´ has no left child, replace ´ by its right child. The
!
Suppression ! Ifbe´NIL
has. no(Ifleft right child
´’s child, is NIL
replace ´ by, then this case
its right child.hand
Th
hasNIL
be no. children.)
(If ´’s right child is NIL , then this case hand
3 cas à considérer en fonction du nœud z à supprimer :
has no children.)
z n’a pas de fils gauche : qremplacer z par son filsq droit
q q
z r
NIL z r r
NIL r
! If ´ has just one child, and that child is its left child
z n’a pas de fils droit child.
! If: remplacer
´ has just zone
parchild,
son fils
andgauche
that child is its left chil
child. q q
q q
z l
l zNIL l
l NIL
! Otherwise, ´ has two children. Find ´’s successor
Dictionnaires 228
subtree and have no left child (the solution to Exerci
this manual
this manual shows why). shows why).
z a deux fils :Goal
rechercher Goalleis
is to replace ´successeur
by y, splicing
to replace yy y,
´ by desplicing
out z.its current
of y out location.
of its current location.
NB : y est dans le sous-arbre de droite et n’a pas de fils gauche.
! If y is ´’s!right
If ychild,
is ´’sreplace ´ by y
right child, and leave
replace ´ byy’s rightleave
y and childy’s
alone.
right child
I Si y est le fils droit de z, remplacer z par y et conserver le fils droit de y
q q q q
z z y y
l l y yl l x x
NIL x NIL x
Sinon, y estOtherwise, lies withindroit

yOtherwise,
dans le! sous-arbre y´’s right
de subtree
z mais but issubtree
n’en not
estthepas
rootisofnot
thisthe
subtree
!
I lies within ´’s right but root o
Replace y byReplace
its own yright child. Then replace ´ by y.
la racine. On remplace y par son propre fils droit et on remplace z par y .
by its own right child. Then replace ´ by y.
q q q q q
z z y y
z z y
l r l NIL r l r
l r l NIL r l
y x x
y x x
NIL x
NIL x
Dictionnaires 229
Suppression
Tree-Delete(T , z)
1 if z.left == NIL
2 Transplant(T , z, z.right)
3 elseif z.right == NIL
4 Transplant(T , z, z.left) Transplant(T , u, v )
5 else // z has two children 1 if u. parent == NIL
6 y = Tree-Successor(z) 2 T . root = v
7 if y . parent 6= z 3 elseif u = = u.parent.left
8 Transplant(T , y , y .right) 4 u. parent.left = v
9 y . right = z. right 5 else u. parent.right = v
10 y . right.parent = y 6 if v 6= NIL
11 // Replace z by y 7 v . parent = u.parent
12 Transplant(T , z, y )
13 y .left = z. left
14 y . left.parent = y
Complexité : O(h) pour un arbre de hauteur h
(Tout est O(1) sauf l’appel à Tree-Successor).
Dictionnaires 230
Arbres binaires de recherche
Toutes les opérations sont O(h) où h est la hauteur de l’arbre

Si n éléments ont été insérés dans l’arbre :
I Au pire, h = n − 1 = O(n)
I Elements insérés en ordre
I Au mieux, h = dlog2 ne = O(log n)
I Pour un arbre binaire complet
I En moyenne, on peut montrer que h = O(log n)
I En supposant que les éléments ont été insérés en ordre aléatoire
Dictionnaires 231
Tri avec un arbre binaire de recherche
Binary-Search-Tree-Sort(A)
1 T = “Empty binary search tree”
2 for i = 1 to n
3 Tree-Insert(T , A[i])
4 Inorder-Tree-Walk(T .root)
12.1 What is a binary search tree?
Exemple : A = [6, 5, 7, 2, 5, 8]
6
5 7
2 5 8
Complexité en temps identique au quicksort

I Insertion : en moyenne, n · O(log n) = O(n log n), pire cas : O(n2 )
I Parcours de l’arbre en ordre : O(n)
I (a)
Total : O(n log n) en moyenne, O(n2 ) pour le pire cas
Complexité en espace cependant plus importante, pour le stockage
de la structure d’arbres. Figure 12.1 Binary search trees. For any node x, the k
and the keys in the right subtree of x are at least x: key
Dictionnaires the same set of values. The worst-case running time232 fo
Pire cas En moyenne


ABR Θ(n) Θ(n) Θ(n) Θ(log n) Θ(log n) Θ(log n)
Peut-on obtenir Θ(log n) dans le pire cas ? Oui !

Deux solutions :
I Utiliser de la randomisation pour que le probabilité de rencontrer le
pire cas soit négligeable
I Maintenir les arbres équilibrés
Dictionnaires 233
Plan
1. Introduction

Principe
Adressage ouvert
Comparaisons
Dictionnaires 234
Arbres équilibrés
Solution générale pour obtenir une complexité au pire cas en

O(log n) :
I Définir un invariant sur la structure d’arbre
I Prouver que cette invariant garantit une hauteur Θ(log n)
I Implémenter les opérations d’insertion et suppression de manière à
maintenir l’invariant
I Si ces opérations ne sont pas trop coûteuse (p.ex., O(log n)), on aura
gagné
Plusieurs types d’arbres équilibrés :

I Arbres AVL
I Invariant : Arbres H-équilibrés
I Arbres 2-3-4
I Arbres rouges et noirs
I Splay trees, Scapegoat trees, treaps. . .
Dictionnaires 235
Arbres H-équilibrés
Définition :
T est H − équilibré ⇔ |h(g (T 0 )) − h(d(T 0 ))| ≤ 1,

pour tout sous-arbre T 0 de T , et où g (X ), d(X ) et h(X ) sont resp.
le sous-arbre gauche, le sous-arbre droit et la hauteur de l’arbre X .
(Les hauteurs des deux sous-arbres d’un même nœud diffèrent au
plus de un)
Propriété :
Pour tout arbre H-équilibré de taille n et de hauteur h, on a
h = Θ(log n)
Plus précisément, on peut prouver :
log(n + 1) ≤ h + 1 < 1, 44 log(n + 2)
Dictionnaires 236
Arbres H-équilibrés
Démonstration
Etant donné un arbre H-équilibré de taille n et de hauteur h ≥ 1, pour h
fixé, n est
Maximum : quand l’arbre est complet, soit quand
n = 2h+1 − 1 ⇒ n + 1 ≤ 2h+1 ⇒ log(n + 1) ≤ h + 1 ⇒ h ∈ Ω(logn)
Minimum : quand n = N(h)
Arbres H-équilibrés Arbres
où H-équilibrés
N(h) est la taille d’un arbre
H-équilibré
Démonstration
de hauteur h qui a le moins d’éléments.
Démonstration
N(h)
Etant donné unIarbre peut être
H-équilibré défini
de taille Etant
n etpar
de donné
h un
récurrence
hauteur arbrehH-équilibré de taille n et de hauteur h
par
1, pour
fixé, n est fixé, n est
N(h) = 1 + N(h − 1) + N(h − 2) avec N(0) = 1 et N(1) = 2.
Maximum : quand l’arbre est complet, soit quandMaximum : quand l’arbre est complet, soit quand
h+1 1 ) n + 1  2h+1 ) log(n + 1)  h + 1
n = 2h+1 1 ) n + 1  2h+1 ) log(n + 1)  h n+= 12
Minimum : quand n = N(h) où N(h) est la tailleMinimum d’un arbre: quand n = N(h) où N(h) est la taille d’un a
H-équilibré de hauteur h qui a le moins d’éléments. H-équilibré de hauteur h qui a le moins d’éléments.
I N(h) peut être défini par récurrence par I N(h) peut être défini par récurrence par
N(h) = 1 + N(h 1) + N(h 2) avec N(0) = 1 et N(1) N(h) ==2. 1 + N(h 1) + N(h 2) avec N(0) = 1 et N(1
I En notant F (h) = N(h) + 1, on a F (h) = F (h 1)I+En
F (hnotant
2) avec
F (h) = N(h) + 1, on a F (h) = F (h 1) + F
F (0) = 2, F (1) = 3 F (0) = 2, F (1) = 3
I F est un récurrence de Fibonacci qui a pour solution I F est un récurrence de Fibonacci qui a pour solution
p p p
1 h+3 1 + 5 1 5
F (h) = p ( 0h+3
) avec = et 0 = F (h) = p1 ( h+3 0h+3
) avec =
1+ 5
et 0 =
5 2 2 2
Dictionnaires 5 237
I On a donc
N(h) = 1 + N(h − 1) + N(h − 2)
⇒ N(h) > 2N(h − 2) (car N(h − 1) > N(h − 2))
⇒ N(h) > 2h/2
⇒ h < 2 log N(h)
I dont on peut tirer que h ∈ O(log n)
On en déduit que
h = Θ(log n)
Dictionnaires 238
Borne supérieure plus précise
I En notant F (h) = N(h) + 1, on a F (h) = F (h − 1) + F (h − 2) avec
F (0) = 2, F (1) = 3
I F est un récurrence de Fibonacci qui a pour solution
√ √
1 h+3 0h+3 1+ 5 0 1− 5
F (h) = √ (φ −φ ) avec φ = et φ =
5 2 2
I On a
1
N(h) + 1 = √ (φh+3 − φ0h+3 )
5
I ce qui donne
1 1
n + 1 ≥ √ (φh+3 − φ0h+3 ) > √ (φh+3 − 1)
5 5
(car |φ0 | < 1)
I En prenant le logφ des deux membres :
h + 1 < 1, 44 log(n + 2)
Dictionnaires 239
Arbres AVL
Définition : Un arbre AVL est un arbre binaire de recherche

H-équilibré
Inventé par Adelson-Velskii et Landis en 1960
Recherche :
I Par la fonction Tree-Search puisque c’est un arbre binaire
I Complexité Θ(log n) étant donné la propriété
Insertion :
I On insère l’élément comme dans un arbre binaire classique
I On vérifie que l’invariant est respecté
I Si ce n’est pas le cas, on modifie l’arbre
Dictionnaires 240
Rotation
Rotations Rotation
x x
xx b xx a
Right-Rotate aa
b
b
Right-Rotate
k≥b k≤a
a kk ≥b b k
k≤ aa b
a Left-Rotate
b
a b
k ≤ ak  aa ≤ a ≤ kb  b Left-Rotate
k aa≤kk≤b b kk≥
b b
k≤a a≤k≤b a≤k≤b k≥b
Right-Rotate(x) Left-Rotate(x)
1 Left-Rotate(x)
Right-Rotate(x)
l = x.left Right-Rotate(x)
1Left-Rotate(x)
r = x.right
r ==x.right
12 l 1x.left
= x.left l.right 121 l x.right
= x.left
r = = r.left
x.right
3 l.right = x 32 r.left = x= r.left
2 x.right
2 x.left = r .left
= l.right 2 x.left = l.right
x.right
4 return l 43 return r
3
3 l.right = xr .left = x 3 l.right
r.left==x x
4 4 return
return l r 4 return l r
4 return
Les rotations maintiennent la propriété d’arbre binaire de recherche

Dictionnaires
24
és Arbres H-équilibrés 1
Démonstration N(h) + 1 = p (
Démonstration
Insertion dans un AVL Etant
e H-équilibré de taille n et de donné
Etant
hauteur un
hdonné arbrehH-équilibré
un arbre
1, pour de de
H-équilibré taille
taillen netetde
dehauteur
hauteur hh 1,
I ce qui donne
1, pour
pour hh
5
fixé, n estn est
fixé,
nd l’arbre est complet, soit quandMaximum Maximum : quand l’arbre
: quand estest
l’arbre complet,
complet,soit soitquand
quand 1
h+1 h+1 h+1h+1 log(n n + 1 p ( h+3 0h+
n + 1  2h+1 ) log(n + 1)  h n+= 1 2n = 2 1 )1 n)+n1+1 2 2 )) log(n++1)1)hh++11 5
d’unMinimum
nd n = N(h) où N(h) est la tailleMinimum : quand
arbre: quand n =n N(h)
= N(h) oùoù N(h)estestlalataille
N(h) tailled’un
d’un arbre
arbre
H-équilibré
H-équilibré
auteur h qui a le moins d’éléments. de hauteur
de hauteur h qui
h qui a lea le
moins (car | 0 | < 1)
moinsd’éléments.
d’éléments.
I N(h)I N(h) peut être défini par récurrence par I En prenant le log des deux membres
tre défini par récurrence par peut être défini par récurrence par
N(h 1) + N(h 2) avec N(0) = 1 et N(1) N(h) =N(h)
2. 1 =
= + 1N(h+ N(h1) + 1)N(h
+ N(h 2) 2) avecN(0)
avec N(0)==11etetN(1)
N(1) == 2.
2.
I En notant F (h) = N(h) + 1, on a F (h) = F (h
(h) = N(h) + 1, on a F (h) = F (h 1)I+En F (h F (h) = N(h) + 1, on a F (h) = F (h 1)1)++FF(h
2) avec
notant (h 2) 2) avec
avec h + 1 < 1, 44 l
(1) = 3 F (0)F=(0)2,=F2,(1)F =
(1)3= 3
urrence de Fibonacci qui a pour solution
Dictionnaires
p p p p
1 F 5(h) 1= p1 ( h+3 1 +p 5 1 p5
1 h+3
p ( 0h+3
) avec =
1+ 5 0
et = F (h) = p ( h+3
5
0h+3
0h+3 ) avec =1 + 5 et 0 0 = 1
) avec = 2 et = 2
u5
5 2 2 2 2
5
Insérer le nouvel élément comme dans un arbre binaire de recherche

Dictionnaires
Dictionnaires
30 30
30
ordinaire
L’insertion peut créer un déséquilibre (l’arbre n’est plus H-équilibré)
Remonter depuis le nouveau nœud jusqu’à la racine en restaurant
l’équilibre des sous-arbres rencontrés si nécessaire
Dictionnaires 242
Equilibrage
Soit x le nœud le plus bas violant l’invariant après l’insertion
I Tous ses sous-arbres sont H-équilibrés
I Il y a une différence d’au plus 2 niveaux entre ses sous-arbres gauche
et droit
Comment rétablir l’équilibre ?
Deux cas possibles (selon insertion à droite ou à gauche) :
Cas 1 Cas 2
h+2 h+2
x x
h 1 h+1 h+1 h 1
(Déséquilibre à droite) (Déséquilibre à gauche)
Dictionnaires 243
Cas 1 : déséquilibre à droite
Deux sous-cas possibles
Cas 1.1 Cas 1.2

h+2 h+2
x x
h+1 y h+1
h 1 y h 1
h 1 h h 1
A h A
B C
C B
Déséquilibre à l’extérieur Déséquilibre à l’intérieur

(Cas droite-droite) (Cas droite-gauche)
(Pourquoi le cas B et C de hauteur h n’est pas possible ?)
Dictionnaires 244
Cas 1.1 : déséquilibre à droite, extérieur (droite-droite)
Equilibre rétabli par une rotation à gauche de x

Cas 1 : y est déséquilibré à droite
Left-Rotate(x)
h+2 h+1
x y
h+1 h
h 1 y x h
h 1 h 1 h 1
A h
B A C
B
C
Dictionnaires
Dictionnaires 245
Cas 1.2 : déséquilibre à droite, intérieur (droite-gauche)
Une rotation à gauche ne permet
Cas 1 : pas
y estde rétablir l’équilibre
déséquilibré à droite
Left-Rotate(x)
h+2 h+2
x y
h+1 h+1
h 1 y x h 1
h h 1 h 1
A h C
C A
B B
Le sous-arbre B contient au moins un élément (l’élément inséré)

h h
z
Dictionnaires z
h h 1 h 2
h 2 h 1
B
⌘ Bl ou Br
Br Bl
Dictionnaires 246
Left-Rotate(x)
h+2 h+2
Cas 1.2 : déséquilibre à droite, intérieur (droite-gauche)

y x
h+1 h+1
h 1 y x h 1
h h 1 h 1
A h C
C A
B B
Equilibre rétabli par deux rotations
Cas 1 : y est déséquilibré à droite
Right-Rotate(y )
Left-Rotate(x)
h+2 h+1
x
Dictionnaires
z
h y h
h 1 y h+1 x
h
z
Dictionnaires
h 1 h 1 h 1
A
Bl Br
C A C
Bl Br h
ou
2
h 1
Dictionnaires
Dictionnaires 247
Cas 2 : déséquilibre à gauche
Symétrique du cas 1
Deux sous-cas possibles
Cas 2.1 Cas 2.2

h+2 h+2
x x
h+1 h+1
y h 1 y h 1
h 1 h 1
h h
C C
B A
A B
Déséquilibre à l’extérieur Déséquilibre à l’intérieur

(Cas gauche-gauche) (Cas gauche-droite)
Résolus respectivement pas une rotation (à droite) et une double

rotation.
Dictionnaires 248
Implémentation
Algorithme récursif : Pour insérer une clé dans un arbre T :

I On l’insère (récursivement) dans le sous-arbre approprié (gauche ou
droit)
I Si l’arbre résultant T devient déséquilibré, on effectue une rotation
simple ou double selon le cas dans lequel on se trouve
L’arbre après rééquilibrage étant de la même hauteur qu’avant
l’insertion, on n’aura à faire qu’au plus une rotation (simple ou
double).
L’implémentation est facilitée si on maintient en chaque nœud x un
attribut x.h avec la hauteur du sous-arbre en x.
Complexité :
I O(h) où h est la hauteur de l’arbre,
I c’est-à-dire O(log n) vu que l’arbre est H-équilibré.
Dictionnaires 249
Suppression
Comme pour l’insertion, on doit rétablir l’équilibre suite à la

suppression
La suppression d’un nœud peut déséquilibrer le parent de ce nœud
Contrairement à l’insertion, on peut devoir rééquilibrer plusieurs
ancêtres du nœud supprimé.
Chaque rotation étant d’ordre O(1), la complexité d’une suppression
reste cependant O(h) pour un arbre de hauteur h et donc O(log n)
pour un AVL.
Dictionnaires 250
Tri avec un AVL
Comme avec un arbre de binaire de recherche ordinaire, on peut

trier avec un AVL
I On insère les éléments successivement dans l’arbre
I On effectue un parcours en ordre de l’arbre
Complexité en temps : Θ(n log n) (comme pour le tri par tas)
Complexité en espace : Θ(n) (pour la structure d’arbre temporaire)
(versus O(1) pour le heap-sort)
Dictionnaires 251
Pire cas En moyenne


AVL Θ(log n) Θ(log n) Θ(log n) Θ(log n) Θ(log n) Θ(log n)

Oui, en changeant radicalement de philosophie
Dictionnaires 252
Demo
Illustrations :
http://people.ksp.sk/~kuko/bak/
http://www.csi.uottawa.ca/~stan/csi2514/applets/avl/BT.html
http://www.cs.jhu.edu/~goodrich/dsa/trees/avltree.html
Dictionnaires 253
Plan
1. Introduction

Principe
Adressage ouvert
Comparaisons
Dictionnaires 254
Tableau à accès direct
On suppose :
I que chaque élément a une clé tirée d’un univers
U = {0, 1, . . . , m − 1} où m n’est pas trop large
I qu’il ne peut pas y avoir deux éléments avec la même clé.
Le dictionnaire est implémenté par un tableau T [0 . . . m − 1] :
I Chaque position dans la table correspond à une clé de U.
I S’il y a un élément x avec la clé k, alors T [k] contient un pointeur
vers x.
I Sinon, T [k] est vide (T [k] = NIL).
Dictionnaires 255
Each of these operations takes only O.1/ time.
T
0
key satellite data
U 1
(universe of keys) 2
0 6 2
9 7
3
3
4
4
1
K 2 5
5
(actual 3 6
keys) 5
8 7
8
8
9
Direct-Address-Search(T , k)
Figure 11.1 How to implement a dynamic set by a direct-address table T . Each key in the universe
U D f0; 1; : : : ; 9g1 corresponds
return toTan
[k]index in the table. The set K D f2; 3; 5; 8g of actual keys
determines the slots in the table that contain pointers to elements. The other slots, heavily shaded,
contain NIL . Direct-Address-Insert(T , x)
1 return T [x. key ] = x
Direct-Address-Delete(T , x)
1 return T [x.key ] = NIL
Dictionnaires 256
Complexité de toutes les opérations : O(1) (dans tous les cas)

Problème :
I Complexité en espace : Θ(|U|)
I si l’univers de clés U est large, stocker une table de taille |U| peut
être peu pratique, voire impossible
Souvent l’ensemble des clés réellement stockées, noté K , est petit
comparé à U et donc l’espace alloué est gaspillé.
Comment bénéficier de l’accès rapide d’une table à accès direct avec

une table de taille raisonnable ?
⇒ Table de hachage :
I Réduit le stockage à Θ(|K |)
I Recherche en O(1) (en moyenne !)
Dictionnaires 257
Table de hachage
Inventée en 1953 par Luhn

Idée :
I Utiliser une table T de taille m << |U|
I stocker x à la position h(x.key ), où h est une fonction de hachage :
h : U → {0, . . . , m − 1}
Hash-Insert(T , x) Hash-Delete(T , x)
1 T [h(x. key )] = x 1 T [h(x. key )] = NIL
Hash-Search(T , x)
1 return T [h(x. key )]
Est-ce que ces algorithmes sont corrects ?
Dictionnaires 258
key k. Figure 11.2 illustrates the basic idea. The hash function reduces the range
of array indices and hence the size of the array. Instead of a size of jU j, the array
Table de hachage : collisions
can have size m.
T
0
U
(universe of keys)
h(k1)
h(k4)
k1
K k4
(actual k5 h(k2) = h(k5)
keys)
k2
k3 h(k3)
m–1
Figure 11.2 Using a hash function h to map keys to hash-table slots. Because keys k2 and k5 map
Collision : tolorsque deux
the same slot, clés distinctes k1 et k2 sont telles que
they collide.
h(k1 ) = h(k2 )
Cela se produit toujours lorsque le nombre de clés observées est plus
grand que la taille du tableau T (|K | > m)
Très probable, même lorsque la fonction de hachage répartit les clés
uniformément ⇒ Paradoxe des anniversaire
Dictionnaires 259
Paradoxe des anniversaires
Hypothèse :
I On néglige les années bissextiles
I Les 365 jours présentent la même probabilités d’être un jour
d’anniversaire
Si p est la probabilité d’une collision d’anniversaire :
364 363 362 365 − n + 1 365!
1−p = · · ... =
365 365 365 365 (365 − n)!365n
Exemples :
I n = 23 ⇒ p > 0, 5
I n = 57 ⇒ p > 0, 99
I n = 70 ⇒ p > 0, 999
Pour une table de hachage :

I m = 365 et 57 clés ⇒ plus de 99% de chance de collision
I m = 1000000 et 2500 clés ⇒ plus de 95% de chance de collision
Dictionnaires 260
Collision
Pour éviter les collisions :

I on veille à utiliser une fonction de hachage qui disperse le plus
possible les clés vers les différents compartiments.
I on utilise un nombre de compartiments suffisamment grand
Cependant, même dans ce cas, la probabilité de collision peut être
non négligeable.
Deux approches pour prendre en compte les collisions :

I Le chaı̂nage (adressage fermé)
I Le sondage (adressage ouvert)
Dictionnaires 261
Résolution des collisions par chaı̂nage
Solution : mettre les éléments qui sont “hachés” vers la même position
11.2liste
dans une Hashliée
tables(simple ou double) 257
U k1 k4
(universe of keys)
k1
K k4 k5
(actual k5 k2 k7
k7
keys)
k2 k3
k8 k3
k6
k8 k6
Figure 11.3 Collision resolution by chaining. Each hash-table slot T Œj ! contains a linked list of
all the keys whose hash value is j . For example, h.k1 / D h.k4 / and h.k5 / D h.k7 / D h.k2 /.
The linked list can be either singly or doubly linked; we show it as doubly linked because deletion is
faster that way.
Dictionnaires 262
Implémentation des opérations
Chained-Hash-Insert(T , x) Chained-Hash-Delete(T , x)
1 List-Insert(T [h(x. key )], x) 1 List-Delete(T [h(x. key )], x)
Chained-Hash-Search(T , k)
1 return List-Search(T [h(k)], k)
Complexité :
I Insertion : O(1)
I Suppression : O(1) si liste doublement liée, O(n) pour une liste de
taille n si liste simplement liée.
I Recherche : O(n) si liste de taille n.
Dictionnaires 263
Analyse du cas moyen
Recherche d’une clé k dans la table :
I recherche positive : la clé k se trouve dans la table
I recherche négative : la clé k n’est pas dans la table
n
Le facteur de charge d’une table de hachage est donné par α =
Uniform hashing assumption m
où :
I n est le nombre d’éléments dans la table
Uniform hashing assumption. Each key is equally likely to hash to an integer

I m est la taille de la table (c’est-à-dire, le nombre de listes liées)
between 0 and Muniforme

hachage - 1. simple : Pour toute clé k ∈ U,
1
Proba{h(k) = i} = , ∀i ∈ {0, . . . , m − 1}
m
Bins and balls. Throw balls uniformly at random into M bins.
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Dictionnaires 264
Analyse du cas moyen
Hypothèses :
I h produit un hachage uniforme simple
I le calcul de h(k) est Θ(1)
I Insertion en début de liste
⇒ complexités moyennes :
I recherche négative : Θ(1 + α)
I recherche positive : Θ(1 + α)
Si n = O(m), (m croı̂t au moins linéairement avec n),
O(m)
α= = O(1)
m
Toutes les opérations sont donc O(1) en moyenne
Dictionnaires 265
Analyse du cas moyen : recherche négative
La clé k ne se trouve pas dans la table

Par la propriété de hachage uniforme simple, elle a la même
probabilité d’être envoyée vers chaque position dans la table.
Recherche négative requière le parcours de la liste T [h(k)] complète
Cette liste a une longueur moyenne E [nh(k) ] = α.
Le nombre d’éléments à examiner lors d’une recherche négative est
donc α.
En ajoutant le temps de calcul de la fonction de hachage, on arrive à
une complexité moyenne Θ(1 + α).
Dictionnaires 266
Analyse du cas moyen : recherche positive
La clé k se trouve dans la table

Supposons qu’elle ait été insérée à la i-ième étape (parmi n).
I Le nombre d’éléments à examiner pour trouver la clé est le nombre
d’éléments insérés à la position h(k) après k plus 1 (la clé k
elle-même).
I En moyenne, sur les n − i insertions après k, il y en aura (n − i)/m
qui correspondront à la position h(k).
k ayant pu être insérée à n’importe quelle étape parmi n avec une
probabilité 1/n :
n n n
1 n−i 1 X 1 n(n + 1) α α
(n2 −
X X
(1+ ) = 1+ ( n− i) = 1+ ) = 1+ −
i=1
n m nm i=1 i=1
nm 2 2 2n
En tenant compte du coût du hachage, la complexité en moyenne

est donc Θ(2 + α/2 − α/2n) = Θ(1 + α).
Dictionnaires 267
Plan
1. Introduction

Principe
Adressage ouvert
Comparaisons
Dictionnaires 268
Idéalement, la fonction de hachage

I devrait être facile à calculer (O(1))
I devrait satisfaire l’hypothèse de hachage uniforme simple
La deuxième propriété est très difficile à assurer en pratique :
I La distribution des clés est généralement inconnue
I Les clés peuvent ne pas être indépendantes
En pratique, on utilise des heuristiques basées sur la nature attendue
des clés
Si toutes les clés sont connues, il existe des algorithmes pour
construire une fonction de hachage parfaite, sans collision
(Exemple : le logiciel gperf)
Dictionnaires 269
Fonctions de hachage : codage préalable
Les fonctions de hachages supposent que les clés sont des nombres
naturels
Si ce n’est pas le cas, il faut préalablement utiliser une fonction de
codage
Exemple : codage des chaı̂nes de caractères :
I On interprète la chaı̂ne comme un entier dans une certaine base
I Example pour “SDA” : valeurs ASCII (128 possibles) :
S = 83, D = 68, A = 65
I Interprété comme l’entier : (Pourquoi pas 83+68+65 ?)
(83 · 1282 ) + (68 · 1281 ) + (65 · 1280 ) = 1368641
I Calculé efficacement par la méthode de Horner :
((83 · 128 + 68) · 128 + 65)
Dictionnaires 270
Méthode de division
La fonction de hachage calcule le reste de la division entière de la clé par
la taille de la table
h(k) = k mod m.
Exemple : m = 20 et k = 91 ⇒ h(k) = 11.
Avantages : simple et rapide (juste une opération de division)
Inconvénients : Le choix de m est très sensible et certaines valeurs
doivent être évitées
Exemples :
Si m = 2p pour un entier p, h(k) ne dépend que des p bits les moins
significatifs de k
I Exemple : “SDA” mod 128= “GAGA”mod 128=65
Si k est une chaı̂ne de caractère codée en base 2p et m = 2p − 1,
permuter la chaı̂ne ne modifie pas le valeur de hachage
I Exemple : “SDA”=1368641, “DSA”=1124801
⇒ 1368641 mod 127 = 1124801 mod 127 = 89
Dictionnaires 271
Méthode de division
Si la fonction de hachage produit des séquences périodiques, il vaut

mieux choisir m premier
En effet, si m est premier avec b, on a :
{(a + b · i) mod m|i = 0, 1, 2, . . .} = {0, 1, 2, . . . , m − 1}
Exemple : hachage de {206, 211, 216, 221, . . .}

I m = 100 : valeurs hachées possibles : 6, 11,. . . , 96
I m = 101 : toutes les entrées sont exploitées
⇒ Bonne valeur de m : un nombre premier pas trop près d’une

puissance exacte de 2
Dictionnaires 272
Méthode de multiplication
Fonction de hachage :
h(k) = bm · (kA mod 1)c
où
I A est une constante telle que 0 < A < 1.
I kA mod 1 = kA − bkAc est la partie fractionnaire de kA.
Inconvénient : plus lente que la méthode de division
Avantage : la valeur de m n’est plus critique
La méthode marche mieux pour certaines valeurs de A. Par
exemple : √
5−1
A=
2
Dictionnaires 273
Méthode(Relatively)
de multiplication : implémentation
easy implementation:
Calcul aisé siChoose

!
: m D 2p for some integer p.
m = 2p Let pourtheunword sizepof the machine be w bits.
!
entier
! Assume that k fits into a single word. (k takes w bits.)
Les mots sont codés en w bits et les clés k peuvent être codées par
!
un seul motLet s be an integer in the range 0 < s < 2w . (s takes w bits.)
! Restrict A to be of the form s=2w .
A de la forme S/2w pour 0 < s < 2w
w bits
× s D A ! 2w
r1 r0
extract p bits
binary point h.k/
! Multiply k by s.
Exemple : m = 23 , w = 5 (⇒ 0 < s < 25 ), s = 13, A = 13/32 ⇒ h(21) = 4 w
! Since we’re multiplying two w-bit words, the result is 2w bits, r1 2 Cr
Dictionnaires
r1 is the high-order word of the product and r0 is the low-order word.
274
Plan
1. Introduction

Principe
Adressage ouvert
Comparaisons
Dictionnaires 275
Adressage ouvert : principe
Alternative au chaı̂nage pour gérer les collisions

Tous les éléments sont stockés dans le tableau (pas de listes
chaı̂nées)
Ne fonctionne que si α ≤ 1
Pour insérer une clé k, on sonde les cases systématiquement à partir
de h(k) jusqu’à en trouver une vide.
Différentes méthodes en fonction de la stratégie de sondage
Dictionnaires 276
Adressage ouvert : stratégie de sondage
On définit une nouvelle fonction de hachage qui dépend de la clé et du
numéro du sondage :
h : U × {0, 1, . . . , m − 1} → {0, 1, . . . , m − 1}
et qui est telle que
hh(k, 0), h(k, 1), . . . , h(k, m − 1)i
est une permutation de h0, 1, . . . , m − 1i.

0 1 2 m-1
h(k,0) h(k,1) h(k,2) h(k,3)
Dictionnaires 277
Adressage ouvert : recherche et insertion
Hash-Search(T , k) Hash-Insert(T , k)
1 i =0 1 i =0
2 repeat 2 repeat
3 j = h(k, i) 3 j = h(k, i)
4 if T [j] == k 4 if T [j] == NIL
5 return j 5 T [j] = k
6 i = i +1 6 return j
7 until T [j] == NIL or i == m 7 else i = i + 1
8 return NIL 8 until i == m
9 error “hash table overflow”
0 1 2 m-1
h(k,0) h(k,1) h(k,2) h(k,3)
Dictionnaires 278
Adressage ouvert : suppression
La suppression est possible mais pas aisée

I On évitera l’utilisation de l’adressage ouvert si on prévoit de
nombreuses suppressions de clés dans le dictionnaire
On ne peut pas naı̈vement mettre NIL dans la case contenant la clé
k qu’on désire effacer
Solution :
I Utiliser une valeur spéciale DELETED au lieu de NIL pour signifier
qu’on a effacé une valeur dans cette case
I Lors d’une recherche : considérer un case contenant DELETED
comme une case contenant une clé
I Lors d’une insertion : considérer une case contenant DELETED
comme une case vide.
Inconvénient : le temps de recherche ne dépend maintenant plus du
facteur de charge α de la table
Dictionnaires 279
Stratégies de sondage
Soit hk = hh(k, 0), h(k, 1), . . . , h(k, m − 1)i la séquence de sondage

correspondant à la clé k.
Hachage uniforme :
I chacun des m! permutations de h0, 1, . . . , m − 1i a la même
probabilité d’être la séquence de sondage d’une clé k.
I Difficile à implémenter.
En pratique, on se contente d’une garantie que la séquence de
sondage soit une permutation de h0, 1, . . . , m − 1i.
Trois techniques pseudo-uniformes :

I sondage linéaire
I sondage quadratique
I double hachage
Dictionnaires 280
Sondage linéaire
h(k, i) = (h0 (k) + i) mod m,

où h0 (k) est une fonction de hachage ordinaire à valeurs dans
{0, 1, . . . , m − 1}.
Propriétés :
très facile à implémenter
effet de grappe fort : création de longues suites de cellules occupées
i+1
I La probabilité de remplir un cellule vide est m où i est le nombre de
cellules pleines précédant la cellule vide
pas très uniforme
Dictionnaires 281
Sondage quadratique
h(k, i) = (h0 (k) + c1 i + c2 i 2 ) mod m,

où h0 est une fonction de hachage ordinaire à valeurs dans
{0, 1, . . . , m − 1}, c1 et c2 sont deux constantes non nulles.
Propriétés :
nécessité de bien choisir les constantes c1 et c2 (pour avoir une
permutation de h0, 1, . . . , m − 1i)
effet de grappe plus faible mais tout de même existant :
I Deux clés de même valeur de hachage suivront le même chemin
h(k, 0) = h(k 0 , 0) ⇒ h(k, i) = h(k 0 , i)
meilleur que le sondage linéaire
Dictionnaires 282
Double hachage
11.4 Open addressin
h(k, i) = (h1 (k) + ih2 (k)) mod m,
où h1 et h2 sont des fonctions de hachage ordinaires à 0
valeurs dans {0, 1, . . . , m − 1}. 1 79
2
Propriétés : 3
4 69
difficile à implémenter à cause du choix de h1 et h2 5 98
(h2 (k) doit être premier avec m pour avoir une 6
permutation de h0, 1, . . . , m − 1i). 7 72
8
très proche du hachage uniforme
9 14
bien meilleur que les sondages linéaire et 10
quadratique 11 50
12
Exemple : h1 (k) = k mod 13, h2 (k) = 1 + (k mod 11),

insertion de la clé 14 Figure 11.5 Insertio
k mod 13 and h2 .k/ D
Dictionnaires the key 14 into empty
283
Adressage ouvert : élément d’analyse
Pour une table de hachage à adressage ouvert de taille m contenant n

éléments (α = n/m < 1) et en supposant le hachage uniforme
Le nombre moyen de sondages pour une recherche négative ou un
1
ajout est borné par 1−α
Le nombre moyen de sondages pour une recherche positive est borné
1
par α1 log 1−α
⇒ Si α est constant (n = O(m)), la recherche est O(1).

Si α = 0.5, une recherche nécessite en moyenne 2 sondages
(1/(1 − 0.5)).
Si α = 0.9, une recherche nécessite en moyenne 10 sondages
(1/(1 − 0.9)).
Dictionnaires 284
Adressage ouvert versus chaı̂nage
Chaı̂nage :
I Peut gérer un nombre illimité d’éléments et de collisions
I Performances plus stables
I Surcoût lié à la gestion et le stockage en mémoire des listes liées
Adressage ouvert :
I Rapide and peu gourmand en mémoire
I Choix de la fonction de hachage plus difficile (pour éviter les grappes)
I On ne peut pas avoir n > m
I Suppression problématique
D’autres alternatives existent :

I Two-probe hashing
I Cuckoo hashing
I ...
Dictionnaires 285
Le rehachage
Lorsque α se rapproche de 1, les performances s’effondrent

Solution : rehachage : création d’une table plus grande
I allocation d’une nouvelle table
I détermination d’une nouvelle fonction de hachage, tenant compte du
nouveau m
I parcours des entrées de la table originale et insertion dans la nouvelle
table
Si la taille est doublée, le coût asymptotique constant des opérations
est conservé (voir slide 186).
Dictionnaires 286
Universal hashing
Les performances d’un table de hachage se dégrade fortement en cas
de collisions multiples
Connaissant la fonction de hachage, un adversaire malintentionné
pourrait s’amuser à entrer des clés créant des collisions. Exemples :
I Création de fichiers avec des noms bien choisis dans le kernel Linux
2.4.20
I 28/12/2011 : http://www.securityweek.com/
hash-table-collision-attacks-could-trigger-ddos-massive-scale
C’est un exemple d’attaque par déni de service
Parade : hachage universel : choisir la fonction de hachage

aléatoirement à chaque création d’une nouvelle instance de la table
Exemple :
h(k) = ((ak + b) mod p) mod m,
où p est un premier très grand et a et b deux entiers choisis
aléatoirement
Dictionnaires 287
Demo
http://groups.engin.umd.umich.edu/CIS/course.des/cis350/
hashing/WEB/HashApplet.htm
Dictionnaires 288
Plan
1. Introduction

Principe
Adressage ouvert
Comparaisons
Dictionnaires 289
Dictionnaires : résumé
Pire cas En moyenne


AVL Θ(log n) Θ(log n) Θ(log n) Θ(log n) Θ(log n) Θ(log n)
Table de hachage Θ(n) Θ(n) Θ(n) Θ(1) Θ(1) Θ(1)
Cas moyen valable uniquement sous l’hypothèse de hachage

uniforme
Comment obtenir Θ(log n) dans le pire cas avec une table de
hachage ?
Dictionnaires 290
ABR/AVL versus table de hachage
Tables de hachage :
Faciles à implémenter
Seule solution pour des clés non ordonnées
Accès et insertion très rapides en moyenne (pour des clés simples)
Espace gaspillé lorsque α est petit
Pas de garantie au pire cas (performance “instables”)
Arbres binaire de recherche (équilibrés) :

Performance garantie dans tous les cas (stabilité)
Taille de structure s’adapte à la taille des données
Supportent des opérations supplémentaires lorsque les clés sont
ordonnées (parcours en ordre, successeur, prédécesseur, etc.)
Accès et insertion plus lente en moyenne
Dictionnaires 291
Partie 6
Résolution de problèmes
Résolution de problèmes 292

Plan
1. Introduction
2. Approche par force brute
3. Diviser pour régner
4. Programmation dynamique
5. Algorithmes gloutons

Méthodes de résolution de problèmes
Quelques approches génériques pour aborder la résolution d’un

problème :
Approche par force brute : résoudre directement le problème, à
partir de sa définition ou par une recherche exhaustive
Diviser pour régner : diviser le problème en sous-problèmes, les
résoudre, fusionner les solutions pour obtenir une solution au
problème original
Programmation dynamique : obtenir la solution optimale à un
problème en combinant des solutions optimales à des sous-problèmes
similaires plus petits et se chevauchant
Approche gloutonne : construire la solution incrémentalement, en
optimisant de manière aveugle un critère local

Approche par force brute (brute-force)
Consiste à appliquer la solution la plus directe à un problème

Généralement obtenue en appliquant à la lettre la définition du
problème
Exemple simple :
I Rechercher un élément dans un tableau (trié ou non) en le parcourant
linéairement
I Calculer an en multipliant a n fois avec lui-même
I Implémentation récursive naı̈ve du calcul des nombres de Fibonacci
I ...
Souvent pas très efficace en terme de temps de calcul mais facile à
implémenter et fonctionnel

Exemple : tri
Approches par force brute pour le tri :

Un tableau est trié (en ordre croissant) si tout élément est plus petit
que l’élément à sa droite
⇒ tri à bulle : parcourir le tableau de gauche à droite en échangeant
toutes les paires d’éléments consécutifs ne respectant pas cette
définition
Complexité : O(n2 )
⇒ tri par sélection : trouver le minimum du tableau, l’échanger avec
le premier élément, répéter pour trier le reste du tableau

Recherche exhaustive
Une solution par force brute au problème de la recherche d’un

élément possédant une propriété particulière
Générer toutes les solutions possibles jusqu’à en obtenir une qui
possède la propriété recherchée
Exemple pour le tri :
I Générer toutes les permutations du tableau de départ (une et une
seule fois)
I Vérifier si chaque tableau permuté est trié. S’arrêter si c’est le cas.
I Complexité : O(n! · n)
Généralement utilisable seulement pour des problèmes de petite taille
Dans la plupart des cas, il existe une meilleure solution
Dans certain cas, c’est la seule solution possible

Problème du voyageur de commerce
Etant donné n villes et les distances entre ces villes

Trouver le plus court chemin qui passe par toutes les villes
exactement une fois avant de revenir à la ville de départ
2 Tour Coût
A B A-B-C-D-A 17
5 A-B-D-C-A 21
3 4
8 A-C-B-D-A 20
A-C-D-B-A 21
C D A-D-B-C-A 20
7 A-D-C-B-A 17
Recherche exhaustive : O(n!)

On n’a pas encore pu trouver un algorithme de complexité
polynomiale (et il y a peu de chance qu’on y arrive)

Force brute/recherche exhaustive
Avantages :
Simple et d’application très large
Un bon point de départ pour trouver de meilleurs algorithmes
Parfois, faire mieux n’en vaut pas la peine
Inconvénients :
Produit rarement des solutions efficaces
Moins éléguant et créatif que les autres techniques
Dans ce qui suit, on commencera la plupart du temps par fournir la

solution par force brute des problèmes, qu’on cherchera ensuite à
résoudre par d’autres techniques


problème :
problème original

Plan
1. Introduction

Exemple 1 : calcul du minimum/maximum d’un tableau
Exemple 2 : Recherche de pics
Exemple 3 : sous-séquence de somme maximale

Approche diviser-pour-régner (Divide and conquer)
Principe général :
Si le problème est trivial, on le résoud directement
Sinon :
1. Diviser le problème en sous-problèmes de taille inférieure (Diviser)
2. Résoudre récursivement ces sous-problèmes (Régner)
3. Fusionner les solutions aux sous-problèmes pour produire une solution
au problème original

Exemples déjà rencontrés
Merge sort :
1. Diviser : Couper le tableau en deux sous-tableaux de même taille
2. Régner : Trier récursivement les deux sous-tableaux
3. Fusionner : fusionner les deux sous-tableaux
Complexité : Θ(n log n) (force brute : Θ(n2 ))
Quicksort :
1. Diviser : Partionner le tableau selon le pivot
2. Régner : Trier récursivement les deux sous-tableaux
3. Fusionner : /
Complexité en moyenne : Θ(n log n) (force brute : Θ(n2 ))
Recherche binaire (dichotomique) :
1. Diviser : Contrôler l’élement central du tableau
2. Régner : Chercher récursivement dans un des sous-tableaux
3. Fusionner : trivial
Complexité : O(log n) (force brute : O(n))

Exemple 1 : Calcul du minimum/maximum d’un tableau
Approche par force brute pour trouver le minimum ou le maximum

d’un tableau
Min(A) Max(A)
1 min = A[1] 1 max = A[1]
2 for i = 2 to A. length 2 for i = 2 to A. length
3 if min > A[i] 3 if max < A[i]
4 min = A[i] 4 max = A[i]
5 return min 5 return max
Complexité : Θ(n) (n − 1 comparaisons)

I Non, pas en notation asymptotique (le problème est Θ(n))
I Par contre, on peut diminuer le nombre total de comparaisons pour
calculer à la fois le minimum et le maximum

Calcul simultané du minimum et du maximum
Approche diviser-pour-régner pour le calcul simultané du minimum
et du maximum
Max-Min(A, p, r )
1 if r − p ≤ 1
2 if A[p] < A[r ]
3 return (A[r ], A[p])
4 else return (A[p], A[r ])
5 q = b p+r
2 c
6 (max1, min1) = Max-Min(A, p, q)
7 (max2, min2) = Max-Min(A, q + 1, r )
8 return (max(max1, max2), min(min1, min2))
Appel initial : Max-Min(A, 1, A.length)
Correct ? Oui (preuve par induction)

Complexité ?
Analyse de complexité
En supposant que n est une puissance de 2, le nombre de
comparaisons T (n) est donné par :

1 si n = 2
T (n) =
2T (n/2) + 2 sinon
qui se résoud en :
T (n) = 2T (n/2) + 2
= 4T (n/4) + 4 + 2
= 8T (n/4) + 8 + 4 + 2
i
2i T (n/2i ) + 2j
X
=
j=1
log2 (n)−1
2log2 (n)−1 T (2) + 2j

X
=
j=1
= 3/2n − 2
C’est-à-dire 25% de comparaisons en moins que les méthodes

séparées
Exemple 2 : Recherche de pics
1 1 2 6 5 3 7 4 1
Soit un tableau A[1 . . A.length]. On supposera que

A[0] = A[A.length + 1] = −∞.
Définition : A[i] est un pic s’il n’est pas plus petit que ses voisins :
A[i − 1] ≤ A[i] ≥ A[i + 1]
(A[i] est un maximum local)

But : trouver un pic dans le tableau (n’importe lequel)
Note : il en existe toujours un

Approche par force brute
Tester toutes les positions séquentiellement :
Peak1d(A)
1 for i = 1 to A.length
2 if A[i − 1] ≤ A[i] ≥ A[i + 1]
3 return i
Complexité : O(n) dans le pire cas

Approche par force brute 2
Le maximum global du tableau est un maximum local et donc un pic
Peak1d(A)
1 m = A[0]
2 for i = 1 to A. length
3 if A[i] > A[m]
4 m=i
5 return m
Complexité : Θ(n) dans tous les cas

Une meilleure idée
Approche diviser-pour-régner :
Sonder un élément A[i] et ses voisins A[i − 1] et A[i + 1]
Si c’est un pic : renvoyer i
Sinon :
I les valeurs doivent croı̂tre au moins d’un côté
A[i − 1] > A[i] ou A[i] < A[i + 1]
I Si A[i − 1] > A[i], on cherche le pic dans A[1 . . i − 1]

I Si A[i + 1] > A[i], on cherche le pic dans A[i + 1 . . A. length]
1 1 2 6 > 5 3 7 4 1
A quel position i faut-il sonder ?

Algorithme
Peak1d(A, p, r )
1 q = b p+r
2 c
2 if A[q − 1] ≤ A[q] ≥ A[q + 1]
3 return q
4 elseif A[q − 1] > A[q]
5 return Peak1d(A, p, q − 1)
6 elseif A[q] < A[q + 1]
7 return Peak1d(A, q + 1, r )
Appel initial : Peak1d(A, 1, A.length)

Analyse
Correction : oui
I On doit prouver qu’il y aura un pic du côté choisi
I Preuve par l’absurde :
I Supposons que A[q + 1] > A[q] et qu’il n’y ait pas de pic dans
A[q + 1 . . r ]
I On doit avoir A[q + 2] > A[q + 1] (sinon A[q + 1] serait un pic)
I On doit avoir A[q + 3] > A[q + 2] (sinon A[q + 1] serait un pic)
I ...
I On doit avoir A[r ] > A[r − 1] (sinon A[r − 1] serait un pic)
I Comme A[r ] > A[r + 1] = −∞, A[r ] est un pic, ce qui contredit
l’hypothèse
Complexité :
I Dans le pire cas, on a T (n) = T (n/2) + c1 et T (1) = c2 (idem
recherche binaire)
I ⇒ T (n) = O(log n)

Extension à 2D Peak
un tableau 2D Peak Finding
2D Finding
•• Soit une matrice n × n de
nombres
• Trouver un élement plus
grand ou égal à ses 4
voisins (max)
(Demaine & Leiserson)
Approche par force brute : O(n2 )

Recherche du maximum : Θ(n2 )

Approche diviser-pour-régner
Divide & Conquer #1
•
•
Chercher le maximum
• global dans la
colonne centrale
•
Si c’est un pic, le
– renvoyer
Sinon appeler la–fonction
récursivement sur
– les colonnes à
gauche (resp.• droite) si le voisin à
gauche (resp. droite)
– est plus grand
(Demaine & Leiserson)

Analyse : correction
On doit prouver qu’il y a bien un pic du côté choisi

Preuve par l’absurde :
I Supposons qu’il n’y ait pas de pic
I Soient A[i, j] le maximum de la colonne centrale et A[i, k] le voisin le
plus grand (k = j − 1 ou k = j + 1)
I A[i, k] doit avoir un voisin A[p1 , q1 ] avec une valeur plus élevée
(sinon, ce serait un pic)
I A[p1 , q1 ] doit avoir un voisin A[p2 , q2 ] avec une valeur plus élevée
(sinon, ce serait un pic)
I ...
I Le voisin doit toujours rester du même côté de la colonne centrale
(puisque A[i, k] > A[i, j] et A[i, j] est la maximum de la colonne j)
I A un certain point, on va manquer de points
I Il doit donc y avoir un pic

Analyse : complexité
O(n) pour trouver le maximum d’une colonne

O(log n) itérations
O(n log n) au total
Peut-on faire mieux ? Oui, il est possible de proposer un algorithme

en O(n) (pas vu dans ce cours)

worked, then it would be easy to determine how to maximize profit: find the highest
and lowest prices, and then work left from the highest price to find the lowest prior
Exemple 3 : Achat/vente d’actions
price, work right from the lowest price to find the highest later price, and take
the pair with the greater difference. Figure 4.2 shows a simple counterexample,
120
110
100
90
80
70
60
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Day 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Price 100 113 110 85 105 102 86 63 81 101 94 106 101 79 94 90 97
Change 13 !3 !25 20 !3 !16 !23 18 20 !7 12 !5 !22 15 !4 7
Figure 4.1 Information about the price of stock in the Volatile Chemical Corporation after the close
Soit le prix d’une
of trading action
over a period of 17 days.au coursaxisde
The horizontal nchart
of the jours
indicatesconsécutifs
the day, and the vertical(prix à la
axis shows the price. The bottom row of the table gives the change in price from the previous day.
fermeture)
On aimerait déterminer rétrospectivement :
I à quel moment, on aurait dû acheter et
I à quel moment, on aurait dû vendre
de manière à maximiser notre gain

Exemple 3 : Achat/vente d’actions
Première stratégie :
Acheter au prix minimum, vendre au prix maximum
Pas correct : Le prix maximum ne suit pas nécessairement le prix
minimum
Deuxième stratégie :
Soit acheter au prix minimum et vendre au prix le plus élevé qui suit
Soit vendre au prix maximum et acheter au 4.1
prixThelemaximum-subarray
plus bas qui problem
précède
11
Pas correct : 10
9
8
7
6
0 1 2 3 4
Troisième stratégie :
Figure 4.2 An example showing that the max
Tester toutes les paires (force brute) or end at the highest price. Again, the horizont
the price. Here, the maximum profit of $3 pe
Correct ? Complexité ? selling after day 3. The price of $7 after day 2
after day 3 is not the highest price overall.

60
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Achat/vente d’actions : transformation
Day 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Price 100 113 110 85 105 102 86 63 81 101 94 106 101 79 94 90 97
Change 13 !3 !25 20 !3 !16 !23 18 20 !7 12 !5 !22 15 !4 7
Figure 4.1 Information about the price of stock in the Volatile Chemical Corporation after the close
ofTransformation
trading over a period ofdu
17 days. The horizontal
problème : axis of the chart indicates the day, and the vertical
axis shows the price. The bottom row of the table gives the change in price from the previous day.
I Calculer le tableau A[i] = (prix du jour i)-(prix du jour i-1) (de taille
A.length = n en supposant qu’on démarre avec un prix au jour 0)
I Déterminer la sous-séquence non vide contiguë de somme maximale
dans A
I Soit A[i . . j] cette sous-séquence. Il aurait fallu acheter juste avant le
jour i (juste après le jour i − 1) et vendu juste après le jour j.
Exemple sur la tableau ci-dessus : A[8 . . 11] est la sous-séquence
maximale de somme 43 ⇒ acheter juste avant le jour 8 et vendre
juste après le jour 11.
Si on peut trouver la sous-séquence maximale dans un tableau, on
aura une solution à notre problème d’achat/vente d’actions

70 Chapter 4 Divide-and-Conquer
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
A 13 –3 –25 20 –3 –16 –23 18 20 –7 12 –5 –22 15 –4 7
maximum subarray
Figure 4.3 The change in stock prices as a maximum-subarray problem. Here, the subar-
ray AŒ8 : : 11!,naı̈ve
Implémentation with sum: 43, has the greatest sum of any contiguous subarray of array A.
I On that
génère tous les sous-tableaux
although computing the cost of one subarray might take time proportional to
I On the
calcule
lengthlaofsomme des when
the subarray, éléments de chaque
computing all ‚.n2sous-tableau
/ subarray sums, we can orga-
I On nize the computation
renvoie les bornessoduthat(d’un)
each subarray sum takes
sous-tableau deO.1/ time,maximale
somme given the values
of previously computed subarray sums, so that the brute-force solution takes ‚.n2 /
Complexité
time.
: Θ(n2 ) sous-tableaux et O(n) pour le calcul de la
somme d’un sous-tableau
So let O(n3 )solution to the maximum-subarray problem.
⇒efficient
us seek a more
On peutWhen doing so, we will usually
l’implémenter en Θ(n2 )speak of “a” maximum subarray rather than “the”
maximum subarray, since there could be more than one subarray that achieves the
maximum sum.
The maximum-subarray problem is interesting only when the array contains
some negative numbers. If all the array entries were nonnegative, then the
maximum-subarray problem would present no challenge, since the entire array
would give the greatest sum.
Max-subarray-brute-force(A)
1 n = A.length
2 max-so-far = −∞
3 for i = 1 to n
4 sum = 0
5 for h = l to n
6 sum = sum + A[h]
7 if sum > max-so-far
8 max-so-far = sum
9 low = l
10 high = h
11 return (low , high)

Nouveau problème :
I trouver un sous-tableau maximal dans A[low . . high]
I fonction maximum-subarray(A, low , high)
Diviser :
I diviser le sous-tableau en deux sous-tableau de tailles aussi proches
que possible
I choisir mid = b(low + high)/2c
Régner :
I trouver récursivement les sous-tableaux maximaux dans ces deux
sous-tableaux
I appeler maximum-subarray(A, low , mid) et
maximum-subarray(A, mid + 1, high)
Fusionner : ?

4.1 The maximum-subarray problem
crosses the midpoint

A
low mid high low i mid
mid C 1
entirely in AŒlow : : mid! entirely in AŒmid C 1 : : high! AŒi : : mid!
(a) (b
Fusionner : Figure 4.4 (a) Possible locations of subarrays of AŒlow : : high!: entirely
in AŒmid C 1 : : high!, or crossing the midpoint mid. (b) Any subarray
I Rechercher un sous-tableau maximum qui traverse la jonction
the midpoint comprises two subarrays AŒi : : mid! and AŒmid C 1 : : j !, w
I Choisir la meilleuremid
solution parmi les 3
< j ! high.
max-crossing-subarray(A, low , mid, high)
I Force brute : Θ(n2maximum
) (car n/2subarray that l’extrémité
choix pour crosses the midpoint, and take
gauche, n/2 choixa sub
sum of the three.
pour l’extrémité droite)
We can easily find a maximum subarray crossing the m
I Meilleure solution : on recherche indépendamment les extrémités
in the size of the subarray AŒlow : : high!. This problem is n
gauche et droite of our original problem, because it has the added restrictio
chooses must cross the midpoint. As Figure 4.4(b) shows, a
the midpoint is itself made of two subarrays AŒi : : mid! and A
low ! i ! mid and mid < j ! high. Therefore, we just n
max-crossing-subarray
Max-crossing-subarray(A, low , mid, high)
1 left-sum = −∞
2 sum = 0
3 for i = mid downto low
4 sum = sum + A[i]
5 if sum > left-sum
6 left-sum = sum
7 max-left = i
8 right-sum = −∞
9 sum = 0
10 for j = mid + 1 to high
11 sum = sum + A[j]
12 4.1 Theifmaximum-subarray
sum > right-sumproblem 71
13 right-sum = sum
14 max-right = j
15 crosses
returnthe(max-left,
midpoint max-right, left-sum + right-sum)
AŒmid C 1 : : j !
mid high low i mid high
mid C 1 mid C 1 j
tirelyComplexité
in AŒlow : : mid!: entirely in AŒmid C 1 : : high!
Θ(n) AŒi : : mid!
(a) (b)
Max-subarray
Max-subarray(A)
1 if high = = low
2 return (low , hig , A[low ])
3 else mid = b(low + high)/2c
4 (left-low , left-high, left-sum) = Max-subarray(A, low , mid)
5 (right-low , right-high, right-sum) = Max-subarray(A, mid + 1, high)
6 (cross-low , cross-high, cross-sum) =
7 Max-crossing-subarray(A, low , mid, high)
8 if left-sum ≥ right-sum and left-sum ≥ cross-sum
9 return (left-low , left-high, left-sum)
10 elseif right-sum ≥ right-sum and right-sum ≥ cross-sum
11 return (right-low , right-high, right-sum)
12 else return (cross-low , cross-high, cross-sum)

Analyse
Si on suppose que n est un multiple de 2, le nombre d’opérations

T (n) est donné par :

c1 si n = 1
T (n) =
2T (n/2) + c2 n sinon
Même complexité que le tri par fusion ⇒ Θ(n log n)

Peut-on faire mieux ? On verra plus loin que oui

Diviser pour régner : résumé
Mène à des algorithmes très efficaces

Pas toujours applicable mais quand même très utile
Applications :
I Tris optimaux
I Recherche binaire
I Problème de sélection
I Trouver la paire de points les plus proches
I Recherche de l’enveloppe convexe (conver-hull)
I Multiplication de matrice (méthode de Strassens)
I ...


problème :
problème original

Plan
1. Introduction
Exemple 1 : découpage de tiges d’acier
Exemple 2 : Fibonacci
Exemple 3 : sous-séquence de somme maximale
Exemple 4 : plus longue sous-séquence commune
Exemple 5 : le problème 0-1 du sac à dos

Exemple 1 : découpage de tiges d’acier
Soit une tige d’acier qu’on découpe pour la vendre morceau par
morceau
Soit une tigene
La découpe d’acier
peut sequ’on
fairedécoupe
que par pour
nombrela vendre
entier de morceau par
centimètres
morceau
Le prix de vente d’une tige dépend (non linéairement) de sa longueur
La
Ondécoupe ne peut le
veut déterminer se revenu
faire que par nombre
maximum qu’onentier de centimètre
peut attendre de la
Le prixd’une
vente de vente
tige d’une tige dépend (non linéairement) de sa longueur
de n centimètre
On veut déterminer
Problème algorithmique le revenu
: maximum qu’on peut attendre de la
vente d’une :tige
I Entrée une de n centimètre
longueur n > 0 et une table de prix pi , pour
Problème
i = 1,algorithmique
2, . . . , n :
II Entrée
Sortie :: le
une longueur
revenu n > 0qu’on
maximum et unepeut
table de prix
obtenir pi , des
pour pourtiges de
i = 1,
longueur
2, . .
n . , n 40
I Sortie : Le revenu maximum qu’on peut obtenir pour des tiges de
Illustration
Soit la table de prix :
Longueur i 1 2 3 4 5 6 7 8 9 10
Prix pi 1 5 8 9 10 17 17 20 24 30
15.1 Rod cutting 361
Découpes15.1possibles
Rod cutting d’une tige de longueur n = 4 361
9 1 8 5 5 8 1
9 1 8 5 5 8 1
(a) (b) (c) (d)
(a) (b) (c) (d)

1 1 5 1 5 1 5 1 1 1 1 1 1
1 1 5 1 5 1 5 1 1 1 1 1 1
(e) (f) (g) (h)
(e) (f)
Meilleur revenu : découpage en 2 tiges (g)de 2 centimètres, (h)
revenu de
Figure 15.2 The 8 possible ways of cutting up a rod of length 4. Above each piece is the
10 value of that piece, according to the sample price chart of Figure 15.1. The optimal strategy is
Figure
part 15.2 The
(c)—cutting possible
the8rod into twoways of of
pieces cutting
lengthup a rod ofhas
2—which length 4. Above
total value 10. each piece is the
value of that piece, according to the sample price chart of Figure 15.1. The optimal strategy is
part (c)—cutting the rod into two pieces of length 2—which has total value 10.
for i D 1; 2; : : : ; n ! 1. We denote a decomposition into pieces using ordinary
1
Enumérer toutes les découpes, calculer leur revenu, déterminer le

revenu maximum
Complexité : exponentielle en n :
I Il y a 2n−1 manières de découper une tige de longueur n (on peut
couper ou non après chacun des n − 1 premiers centimètres)
I Plusieurs découpes sont équivalentes (1+1+2 et 1+2+1 par exemple)
mais même en prenant cela en compte, le nombre de découpes reste
exponentiel
Infaisable pour n un peu grand

Idée
Soit ri le revenu maximum pour une tige de longueur i

Peut-on formuler rn de manière récursive ?
Déterminons ri pour notre exemple :
i ri solution optimale
1 1 1 (pas de découpe)
4 10 2+2
5 13 2+3
7 18 1+6 ou 2+2+3
8 22 2+6 . . .

Formulation récursive de rn : version naı̈ve
rn peut être calculé comme le maximum de :

I pn : le prix sans découpe
I r1 + rn−1 : le revenu max pour une tige de 1 et une tige de n − 1
I r2 + rn−2 : le revenu max pour une tige de 2 et une tige de n − 2
I ...
I rn−1 + r1 .
C’est-à-dire
rn = max(pn , r1 + rn−1 , r2 + rn−2 , . . . , rn−1 + r1 )

Formulation récursive de rn : version simplifiée
Toute solution optimale a un découpe la plus à gauche

On peut calculer rn en considérant toutes les tailles pour la première
découpe et en combinant avec le découpage optimal pour la partie à
droite
Pour chaque cas, on n’a donc qu’à résoudre un seul sous-problème
(au lieu de deux), celui du découpage de la partie droite
En supposant r0 = 0, on obtient ainsi :
rn = max (pi + rn−i )

1≤i≤n

Implémentation récursive directe
La formule récursive peut être implémentée directement
Cut-rod(p, n)
1 if n = = 0
2 return 0
3 q = −∞
4 for i = 1 to n
5 q = max(q, p[i] + Cut-Rod(p, n − i))
6 return q
(p est un tableau de taille n contenant les prix des tiges de tailles 1

à n)
Complexité ?

Implémentation récursive directe : analyse
L’algorithme est extrêmement inefficace à cause des appels récursifs
redondants
364 Chapter 15 Dynamic Programming
Exemple : arbre des appels récursifs pour le calcul de r4
4
3 2 1 0
2 1 0 1 0 0
1 0 0 0
En général, le nombre de nœuds T (n) de l’arbre est 2n .

Figure
Preuve par induction : 15.3 The recursion tree showing recursive calls resulting from a call C UT-ROD.p; n/ for
n D 4. Each node label gives the size n of the corresponding subproblem, so that an edge from
I Cas de base :a T (0)with
parent =label
1 s to a child with label t corresponds to cutting off an initial piece of size s ! t
I Cas inductif :and leaving a remaining subproblem of size t. A path from the root to a leaf corresponds to one of
the 2n!1 ways of cutting up a rod of length n. In general, this recursion tree has 2n nodes and 2n!1
leaves. n−1 n−1
X X
T (n) = 1 + X n!1T (j) = 1 + 2j = 1 + 2n − 1 = 2n
T .n/ D 1 C
j=0 T .j / : j=0 (15.3)
j D0
Complexité de l’algorithme est
The initial 1 is for exponentielle
the call enterm
at the root, and the n T .j / counts the number of calls
Résolution de problèmes (including recursive calls) due to the call C UT-ROD .p; n ! i/, where j D n ! i.
337
Solution par programmation dynamique
Solution : plutôt que de résoudre les mêmes sous-problèmes plusieurs

fois, s’arranger pour ne les résoudre chacun qu’une seule fois
Comment ? En sauvegardant les solutions dans une table et en se
référant à la table à chaque demande de résolution d’un
sous-problème déjà rencontré
On échange du temps de calcul contre de la mémoire
Permet de transformer une solution en temps exponentiel en une
solution en temps polynomial
Deux implémentations possibles :
I descendante (top-down) avec mémoization
I ascendante (bottom-up)

Approche descendante avec mémoization
Memoized-Cut-rod(p, n)
1 Let r [0 . . n] be a new array
2 for i = 1 to n
3 r [i] = −∞
4 return memoized-cut-rod-aux(p, n, r )
Memoized-Cut-rod-aux(p, n, r )
1 if r [n] ≥ 0
2 return r [n]
3 if n = = 0
4 q=0
5 else q = −∞
6 for i = 1 to n
7 q = max(q, p[i] + memoized-cut-rod-aux(p, n − i, r ))
8 r [n] = q
9 return q
(Attention : suppose que le tableau est passé par pointeur)

Approche ascendante
Principe : résoudre les sous-problèmes par taille en commençant d’abord

par les plus petits
Bottom-up-Cut-rod(p, n)
1 Let r [0 . . n] be a new array
2 r [0] = 0
3 for j = 1 to n
4 q = −∞
5 for i = 1 to j
6 q = max(q, p[i] + r [j − i])
7 r [j] = q
8 return r [n]

Programmation dynamique : analyse
Solution ascendante est clairement Θ(n2 ) (deux boucles imbriquées)

Solution descendante est également Θ(n2 )
I Chaque sous-problème est résolu une et une seule fois
I La résolution d’un sous-problème passe par une boucle à n itérations
15.1 Rod cutting
Graphes des sous-problèmes :
4
(une flèche de x à y indique que la résolution de x dépend de la

résolution de y ) Figure 15.4 The subproblem graph for the rod-cutting problem with
give the sizes of the corresponding subproblems. A directed edge .x; y
solution to subproblem y when solving subproblem x. This graph is a red
Figure 15.3, in which all nodes with the same label are collapsed into a
Résolution de problèmes go from parent to child. 341
Reconstruction de la solution
Fonction Bottom-up-Cut-rod calcule le revenu maximum mais
ne donne pas directement la découpe correspondant à ce revenu
On peut étendre l’approche ascendante pour enregistrer également
la solution dans une autre table
Extended-Bottom-up-Cut-rod(p, n)
1 Let r [0 . . n] and s[0 . . n] be new arrays
2 r [0] = 0
3 for j = 1 to n
4 q = −∞
5 for i = 1 to j
6 if q < p[i] + r [j − i]
7 q = p[i] + r [j − i]
8 s[j] = i
9 r [j] = q
10 return r and s
s[j] contient la coupure la plus à gauche d’une solution optimale au

problème de taille i
Reconstruction de la solution
Pour afficher la solution, on doit “remonter” dans s
Print-cut-rod-solution(p, n)
1 (r , s) = Extended-bottom-up-cut-rod(p, n)
2 while n > 0
3 print s[n]
4 n = n − s[n]
Exemple :
i 0 1 2 3 4 5 6 7 8
p[i] 0 1 5 8 9 10 17 17 20
r [i] 0 1 5 8 10 13 17 18 22
s[i] 0 1 2 3 2 2 6 1 2
print-cut-rod-solution(p, 8) ⇒ ”2 6”

Programmation dynamique : généralités
La programmation dynamique s’applique aux problèmes

d’optimisation qui peuvent se décomposer en sous-problèmes de
même nature, et qui possèdent les deux propriétés suivantes :
I Sous-structure optimale : on peut calculer la solution d’un problème
de taille n à partir de la solution de sous-problèmes de taille inférieure
I Chevauchement des sous-problèmes : Certains sous-problèmes
distincts partagent une partie de leurs sous-problèmes
Implémentation directe récursive donne une solution de complexité
exponentielle
Sauvegarde des solutions aux sous-problèmes donne une complexité
linéaire dans le nombre d’arcs et de sommets du graphe des
sous-problèmes

Exemple 2 : Fibonacci
La fonction Fibonacci-Iter vue au début du cours est un exemple
de programmation dynamique (ascendante)
Fibonacci-Iter(n) 5
1 if n ≤ 1
4
2 return n
3 else
3
4 pprev = 0
5 prev = 1
2
6 for i = 2 to n
7 f = prev + pprev
1
8 pprev = prev
9 prev = f
0
10 return f
On peut se contenter de ne stocker que les deux dernières valeurs
Complexité Θ(n) (graphe contient n + 1 nœuds et 2n − 2 arcs)
(Exercice : écrivez la version descendante avec mémoization)
Interlude : Fibonacci en Θ(log n)
Peut-on faire mieux que Θ(n) pour Fibonacci ? Oui !
Propriété : n
Fn+1 Fn 1 1
=
Fn Fn−1 1 0
Preuve par induction :
I Cas de base (n = 1) : ok puisque F0 = 0, F1 = 1, et F2 = 1
I Cas inductif (n ≥ 2) :

Fn+1 Fn Fn Fn−1 1 1
= ·
Fn Fn−1 Fn−1 Fn−2 1 0
n−1
1 1 1 1
= ·
1 0 1 0
n
1 1
=
1 0

Interlude : Fibonacci en Θ(log n)
n
1 1
Approche par force brute pour le calcul de : Θ(n)
1 0
Idée : utiliser le diviser-pour-régner pour le calcul de an
n/2 n/2
n a ·a si n est pair
a =
a(n−1)/2 · a(n−1)/2 · a si n est impair
Complexité : Θ(log n) (comme la recherche binaire)
(Exercice : implémenter l’algorithme)

Exemple 3 : sous-séquence maximale
Max-subarray-linear(A) 4
1 Let m[1 . . n] be a new array
2 max-so-far = A[1] 3
3 m[1] = A[1]
4 for i = 2 to A.length
2
5 if m[i − 1] > 0
6 m[i] = m[i − 1] + A[i]
7 else m[i] = A[i] 1
8 if m[i] > max-so-far
9 max-so-far = m[i] 0
10 return max-so-far
Complexité : Θ(n) (diviser pour régner : Θ(n log n))

m[i] est la somme de la sous-séquence maximale qui se termine en i
L’algorithme calcule m[i] à partir de m[i − 1]
Forme de programmation dynamique ascendante (très simple)
(Exercice : ajouter le calcul des bornes d’un sous-tableau solution, remplacer le
tableau m par une seule variable)
have to be consecutive, but it has to be in order.
Exemple 4 : plus come [To longue sous-séquence
up with examples of longest commune
common subsequences, search t
nary for all words that contain the word you are looking for as a subsequ
Définition : aUne UNIX sous-séquence (non contiguë)
system, for example, d’une
to find all the séquence
words with pine as a sub
use the command grep ’.*p.*i.*n.*e.*’ dict, where dict
hx1 , . . . , xm i est une séquence hxi1 , xi2 , . . . , xik i, où
cal dictionary. Then check if that word is actually a longest common sub
1 ≤ i1 < i2 < . . . < Cikcode
Working ≤ m.for finding a longest common subsequence of two string
Problème : Etant donné 2 séquences, X = hx1 , . . . , xm i and
at http://www.cs.dartmouth.edu/˜thc/code/lcs.c]
Y = hy1 , . . . , yn i, trouver une plus grande sous-séquence commune
aux deux séquences
Examples
Exemples : [The examples are of different types of trees.]
s p r i n g t i m e h o r s e b a c k
p i o n e e r s n o w f l a k e
m a e l s t r o m h e r o i c a l l y
b e c a l m s c h o l a r l y
Brute-force algorithm: 349
Solution par force brute
On énumère toutes les sous-séquences de la séquence la plus courte

Pour chacune d’elles, on vérifie si c’est une sous-séquence de la
séquence la plus longue
Complexité : Θ(n · 2m ) (en supposant que n < m)

I 2m sous-séquences possibles dans une séquence de longueur m
I Vérification de l’occurence d’une sous-séquence dans une séquence de
longueur n en Θ(n)
(Exercice : implémenter la vérification)

Propriété de sous-structure :
Soit Xi = hx1 , . . . , xi i un préfixe de X et Yi = hy1 , . . . , yi i un préfixe
de Y
Soit Z = hz1 , . . . , zk i une plus longue sous-séquence commune de X
et Y
Les propriétés suivantes sont vérifiées :
I Si xm = yn , alors zk = xm = yn et Zk−1 est une plus longue
sous-séquence commune de Xm−1 et Yn−1 .
I Si xm 6= yn , alors zk 6= xm ⇒ Z est une plus longue sous-séquence
commune à Xm−1 et Y
I Si xm 6= yn , alors zk 6= yn ⇒ Z est une plus longue sous-séquence
commune à X et Yn−1
⇒ Une plus longue sous-séquence commune de deux séquence a pour
préfixe une plus longue sous-séquence des préfixes des deux séquences.

Soit c[i, j] la longueur d’une plus longue sous-séquence de Xi et Yj .
Formulation récursive :

 0 si i = 0 ou j = 0,
c[i, j] = c[i − 1, j − 1] + 1 si i, j > 0 et xi = yj ,

max(c[i − 1, j], c[i, j − 1]) si i, j > 0 et xi 6= yj ,
Graphe des sous-problèmes :
0,0 0,1 0,2 0,3
1,0 1,1 1,2 1,3
2,0 2,1 2,2 2,3
3,0 3,1 3,2 3,3
4,0 4,1 4,2 4,3

Implémentation (ascendante)
LCS-Length(X , Y , m, n)
1 Let c[0 . . m, 0 . . n] be a new table
2 for i = 1 to m
3 c[i,0]=0
4 for j = 0 to n
5 c[0,j]=0
6 for i = 1 to m
7 for j = 1 to n
8 if xi = = yj
9 c[i, j] = c[i − 1, j − 1] + 1
10 elseif c[i − 1, j] ≥ c[i, j − 1]
11 c[i, j] = c[i − 1, j]
12 else c[i, j] = c[i, j − 1]
13 return c
Complexité : Θ(m · n)
Illustration
15-10 Lecture Notes for Chapter 15: Dynamic Programming
amputation versus spanking
a m p u t a t i o n
0 0 0 0 0 0 0 0 0 0 0
s 0 0 0 0 0 0 0 0 0 0 0
p 0 0 0 1 1 1 1 1 1 1 1
a 0 1 1 1 1 1 2 2 2 2 2
n 0 1 1 1 1 1 2 2 2 2 3
k 0 1 1 1 1 1 2 2 2 2 3
i 0 1 1 1 1 1 2 2 3 3 3
n 0 1 1 1 1 1 2 2 3 3 4
g 0 1 1 1 1 1 2 2 3 3 4
p a i n
Answer: pain. 354
Trouver la plus longue sous-séquence
LCS-Length(X , Y , m, n)
1 Let c[0 . . m, 0 . . n] be a new table
2 Let b[1 . . m, 1 . . n] be a new table
3 for i = 1 to m
4 c[i,0]=0 Print-LCS(b, X , i, j)
5 for j = 0 to n
1 if i = = 0 or j = = 0
6 c[0,j]=0
2 return
7 for i = 1 to m
3 if b[i, j] = = ” - ”
8 for j = 1 to n
4 Print-LCS(b, X , i − 1, j − 1)
9 if xi = = yj
5 print xi
10 c[i, j] = c[i − 1, j − 1] + 1
6 elseif b[i, j] = = ” ↑ ”
11 b[i, j] = ” - ”
7 Print-LCS(b, X , i − 1, j)
12 elseif c[i − 1, j] ≥ c[i, j − 1]
8 else Print-LCS(b, X , i, j − 1)
13 c[i, j] = c[i − 1, j]
14 b[i, j] = ” ↑ ”
15 else c[i, j] = c[i, j − 1]
16 b[i, j] = ” ← ”
17 return c and b

Exemple 5 : le problème du sac à dos (knapsack)
Problème :
Un voleur se rend dans un musée pour commettre un méfait avec un
sac à dos pouvant contenir W kg.
Le musée comprend n œuvres d’art, chacune de poids pi et de prix
vi (i = 1, . . . , n)
Le problème pour le voleur est de déterminer une sélection d’objets
de valeur totale maximale et n’excédant pas le poids total admissible
dans le sac à dos.
Formellement :
Soit un ensemble S de n objets de poids pi > 0 et de valeurs vi > 0
Trouver x1 , x2 , . . . , xn ∈ {0, 1} tels que :
Pn
Pni=1 xi · pi ≤ W , et
I
i=1 xi · vi est maximal.

I

Exemple
i vi pi
1 1 1
Capacité du sac à dos :
2 6 2
3 18 5
W = 11
4 22 6
5 28 7
Exemple :
{5, 2, 1} a un poids de 10 et une valeur de 35
{3, 4} a un poids de 11 et une valeur de 40

Recherche exhaustive : on énumère tous les sous-ensembles de S, et

on calcule leur poids et leur valeur
Complexité en temps : O(n2n )
Améliorations :
I Ne tester que les sous-ensembles de W /pmin objets où pmin est la
taille minimale
I Tester les objets par ordre croissant et s’arrêter dès que l’un d’entre
eux n’entre plus
Diminue la constante mais la complexité reste la même

Approche par programmation dynamique
Définition : soit M(k, w ), 0 ≤ k ≤ n et 0 ≤ w ≤ W , le bénéfice
maximum qu’on peut obtenir avec les objets 1,. . . ,k de S et un sac
à dos de charge maximale w
(On suppose que les poids pi et W sont entiers)
Deux cas :
I On ne sélectionne pas l’objet k : M(k, w ) est le bénéfice maximum en
sélectionnant parmi les k − 1 premiers objets avec comme limite w
(M(k − 1, w ))
I On sélectionne l’objet k : M(k, w ) est la valeur de l’objet k plus le
bénéfice maximum en sélectionnant parmi les k − 1 premiers objets
avec la limite w − pk

 0 si i = 0
M(k, w ) = M(k − 1, w ) si pi > w

max{M(k − 1, w ), vk + M(k − 1, w − pk )} sinon

Implementation
KnapSack(p, v , n, W )
1 Let M[0 . . n, 0 . . W ] be a new table
2 for w = 1 to W
3 M[0,w]=0
4 for k = 1 to n
5 M[k, 0] = 0
6 for k = 1 to n
7 for w = 1 to W
8 if p[k] > w
9 M[k, w ] = M[k − 1, w ]
10 elseif M[k − 1, w ] > v [k] + M[k − 1, w − p[k]]
11 M[k, w ] = M[k − 1, w ]
12 else M[k, w ] = v [k] + M[i − 1, w − p[k]]
13 return M[n, W ]

Exemple
M 0 1 2 3 4 5 6 7 8 9 10 11
∅ 0 0 0 0 0 0 0 0 0 0 0 0
{1} 0 1 1 1 1 1 1 1 1 1 1 1
{1, 2} 0 1 6 7 7 7 7 7 7 7 7 7
{1, 2, 3} 0 1 6 7 7 18 19 24 25 25 25 25
{1, 2, 3, 4} 0 1 6 7 7 18 22 24 28 29 29 40
{1, 2, 3, 4, 5} 0 1 6 7 7 18 22 28 29 34 35 40
i vi pi
1 1 1
Solution optimale : {4, 3} 2 6 2
Bénéfice : 22 + 18 = 40 W = 11
3 18 5
4 22 6
5 28 7

Récupération des xi
En remontant dans le tableau M :
KnapSack(p, v , n, W )
1 // Compute M
2 ...
3 // Retrieve solution
4 Let x[1 . . n] be a new table
5 w =W
6 for k = n downto 1
7 if M[k, w ] = = M[k − 1, w ]
8 x[k] = 0
9 else
10 x[k] = 1
11 w = w − p[k]
12 return x

Complexité
Complexité en temps et en espace : Θ(nW )

I Remplissage de la matrice M : Θ(nW )
I Recherche de la solution : Θ(n)
(Exercice : proposez une version Θ(n + W ) en espace)
Note : L’algorithme n’est en fait pas polynomial en fonction de la

taille de l’entrée
I Si W nécessite nw bits pour son codage, la complexité est Θ(n2nw )
I Comme pour le voyageur de commerce, on n’a pas encore trouvé
d’algorithme polynomial pour le problème du sac à dos (et il y a peu
de chance qu’on y arrive)

Programmation dynamique : résumé
Grandes étapes :
Caractériser la structure du problème
Définir de manière récursive la valeur de la solution optimale
Calculer les valeurs de la solution optimale (c’est-à-dire remplir un
tableau)
Reconstruire la (une) solution optimale à partir de l’information
calculée (“bottom-up”)
Applications :
Command unix diff (comparaison de fichiers)
Algorithme de Viterbi (reconnaissance vocale)
Alignement de séquences d’ADN (Smith-Waterman)
Plus court chemin dans un graphe (Bellman-Ford)
Compilateurs (analyse syntaxique et optimisation du code)
...
Programmation dynamique versus diviser-pour-régner
L’approche Diviser-pour-régner décompose aussi le problème en

sous-problèmes
Mais ces sous-problèmes sont significativement plus petits que le
problème de départ (n → n/2)
I Alors que la programmation dynamique réduit généralement un
problème de taille n en sous-problèmes de taille n − 1
Et ces sous-problèmes sont indépendants
I Alors qu’en programmation dynamique, ils se recouvrent
Pour ces deux raisons, la récursivité ne fonctionne pas pour la
programmation dynamique


problème :
problème original

Plan
1. Introduction
Exemple 1 : rendre la monnaie
Exemple 2 : sélection d’activités
Exemple 3 : problème du sac à dos
Exemple 4 : codage de Huffman

Algorithme glouton (greedy)
Utilisé pour résoudre des problèmes d’optimisation (comme la
programmation dynamique)
Idée principale :
I Quand on a un choix local à faire, faire le choix (glouton) qui semble
le meilleur tout de suite (et ne jamais le remettre en question)
Pour que l’approche fonctionne, le problème doit satisfaire deux
propriétés :
I Propriété des choix gloutons optimaux : On peut toujours arriver à
une solution optimale en faisant un choix localement optimal
I Propriété de sous-structure optimale : Une solution optimale du
problème est composée de solutions optimales à des sous-problèmes
Même si ces propriétés ne sont pas satisfaites, l’approche gloutonne
peut parfois fournir une approximation intéressante au problème
Parfois, il est possible de caractériser la distance de la solution
gloutonne à la solution optimale

Exemple 1 : rendre la monnaie
Objectif : Etant donné des pièces de 1, 2, 5, 10, et 20 cents, trouver

une méthode pour rembourser une somme de x cents en utilisant le
moins de pièces possible.
Exemple : 34 cents :
I 1ère possibilité : {1, 1, 2, 5, 5, 20} → 6 pièces
I 2ième possibilité : {2, 2, 10, 20} → 4 pièces
Algorithme de la caissière : A chaque itération, ajouter une pièce de

la plus grande valeur qui ne dépasse pas la somme restant à
rembourser
Exemple : 49 cents → {20, 20, 5, 2, 2} (5 pièces)

Implémentation
Algorithme de la caissière : A chaque itération, ajouter une pièce de
la plus grande valeur qui ne dépasse pas la somme restant à
rembourser
CoinchangingGreedy(x, c, n)
1 // c[1 . . n] contains the n coin values in decreasing order
2 Let s[1 . . n] be a new table
3 // s[i] is the number of ith coin in solution
4 CoinCount = 0
5 for i = 1 downto n
6 s[i] = bx/c[i]c
7 x = x − s[i] ∗ c[i]
8 CoinCount = CoinCount + s[i]
9 return (s, CoinCount)
Complexité : O(n) (sans compter le tri des pièces)

Cet algorithme permet-il de trouver une solution optimale ?
Analyse de CoinChangingGreedy
Théorème : l’algorithme CoinChangingGreedy est optimal pour
c = [20, 10, 5, 2, 1]
Preuve :
Soit S ∗ (x) l’ensemble optimal de pièces pour un montant x et soit
c ∗ le plus grand c[i] ≤ x. On doit montrer que :
1. S ∗ (x) contient c ∗ (propriété des choix gloutons optimaux)
2. S ∗ (x) = {c ∗ } ∪ S ∗ (x − c ∗ ) (propriété de sous-structure optimale)
Propriété (2) découle directement de (1)

I S ∗ (x) contient c ∗ par (1)
I Donc S ∗ (x) \ {c ∗ } représente le change pour un montant de x − c ∗
I Ce change doit être optimal sinon S 0 = {c ∗ } ∪ S ∗ (x − c ∗ ) serait une
meilleure solution que S ∗ (x) pour un montant de x
I On a donc S ∗ (x) = {c ∗ } ∪ S ∗ (x − c ∗ )

Propriété (1) : S ∗ (x) contient c ∗
I Avec c = [20, 10, 5, 2, 1], une solution optimale ne contient jamais :
I plus d’une pièce de 1, 5, ou de 10 (car 2 × 1 = 2, 2 × 5 = 10,
2 × 10 = 20)
I plus de deux pièces de 2 (car 3 × 2 = 5 + 1)
I Analysons les différents cas pour x :
x =1 : c ∗ = 1, meilleure solution S ∗ (x) = {1} contient c ∗
2≤x <5 : c ∗ = 2, avec un seul 1, on ne peut pas obtenir x ⇒ c ∗ ∈ S ∗ (x)
x =5 : c ∗ = 5, meilleure solution S ∗ (x) = {5} contient c ∗
5 < x < 10 : c ∗ = 5, avec un seul 1, et deux 2, on ne peut pas obtenir x
⇒ c ∗ ∈ S ∗ (x)
x = 10 : c ∗ = 10, meilleure solution S ∗ (x) = {10} contient c ∗
10 < x < 20 : c ∗ = 10, avec un seul 1, deux 2, et 1 seul 5, on ne peut pas obtenir x
⇒ c ∗ ∈ S ∗ (x)
x = 20 : c ∗ = 20, meilleure solution S ∗ (x) = {20} contient c ∗
x > 20 : c ∗ = 20, avec un seul 1, deux 2, 1 seul 5 et 1 seul 10, on ne peut pas
obtenir x ⇒ c ∗ ∈ S ∗ (x)
I S ∗ (x) contient donc toujours bien c ∗

Analyse de CoinChangingGreedy
L’approche greedy n’est correcte que pour certains choix particuliers

de valeurs de pièces
I ok pour la plupart des monnaies courantes, euros, dollars. . .
Contre-exemple : C = [1, 10, 21, 34, 70, 100] (valeurs de timbres aux
USA) et x = 140
I Algorithme glouton : 100, 34, 1, 1, 1, 1, 1, 1
I Solution optimale : 70, 70
Solution pour résoudre le cas général : programmation dynamique

Très proche du problème de découpage de tige et du sac à dos
(Exercice : écrivez une fonction CoinChangeDP)

Exemple 2 : sélection d’activités
Un salle est utilisée pour différentes activités
I Soit S = {a1 , a2 , . . . , an } un ensemble de n activités
16-2 ai démarre
I Lecture Notes forau temps
Chapter 16:sGreedy
i et seAlgorithms
termine au temps fi
I Deux 16-2
activités ai et aj sont
Lecture Notes compatibles si soit
for Chapter 16: Greedy fi ≤ sj , soit fj ≤ si
Algorithms
Problème
Example
: trouver le plus grand sous-ensemble de tâches
compatibles Example
S sorted by finish time: [Leave on board]
Exemple : S sorted by finish time: [Leave on board]
i 1 2 3 4 5 i6 1 72 38 4 95 6 7 8 9
si 1 2 4 1 5 s 8 1 92 411 1 135 8 9 11 13
i
fi 3 5 7 8 9 f10
i 3 115 714 8 169 10 11 14 16
a5 a5
a4 a4
a2 a2 a7 a7a a9
9
a1 a3 a6 a8
a1 a3 a6 a8
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Maximum-size mutually compatible set: fa1 ; a3 ; a6 ; a8 g.
Maximum-size mutually compatible set: fa ; a ; a ; a g. 374
Un salle est utilisée pour di↵érentes activités
Exemple
Sélection 22 Exemple
::2sélection
d’activités 2 d’activités
:Exemple
2approche gloutonne
I Soit S = {a , a , . . . , a } un ensemble de n activités
Exemple
Exemple
Exemple
I Exemple sélection
Exemple
:2sélection
Exemple
:21Chapter
sélection
:temps
sélection
Exemple
:d’activités
216:sélection
Exemple
s:d’activités
2sélection
Exemple
:d’activités
2sélection
Exemple
:termine
d’activités
2sélection
Exemple
:d’activités
2sélection
Exemple
:d’activités
2ausélection
Exemple
:d’activités
2sélection
Exemple
:d’activités
2sélection
Exemple
f:d’activités
2sélection
:d’activités
2sélection
:d’activités
2sélection
:d’activités
2sélection
:d’activités
sélection
d’activités
d’activités
d’activité
d’activ
n
16-2 ai démarre
Lecture Notes forau i et seAlgorithms
Greedy temps i
Un Isalle Deux est16-2 utiliséeapour
activités et a di↵érentes sont Notes compatibles
activités si soit f  s , soit f  s
SchémaUn Un
salle
Un
salle
Deux
d’une est
Un
salle
est
utilisée
Un
salle
est
utilisée
Un
salle
activités
SIsolution
est
autilisée
ipour
Un
salle
etest
utilisée
=I{a1I, a2I, .gloutonne
pour
Un
asalle
j di↵érentes
est
utilisée
pour
Un
salle
sont di↵érentes
est
utilisée
pour
Un
salle
di↵érentes
est
utilisée
pour
Un
salle
compatibles di↵érentes
est
:un utilisée
activités
pour
Un
salle
di↵érentes
est
utilisée
activités
pour
Un
salle
di↵érentes
est
siutilisée
activités
pour
Un
salle
di↵érentes
soitest
utilisée
activités
pour
Un
salle
fidi↵érentes
est
utilisée
activités
pour
Un
salle
di↵érentes
sest
utilisée
activités
j pour
,Un
salle
di↵érentes
est
utilisée
soitactivités
pour
salle
di↵érentes
fest
utilisée
jactivités
pour
di↵érentes
est
utilisée
activités
spour
i di↵érentes
utilisée
activités
pour di↵érentes
activités
pourdi↵érentes
activités
pour di↵éren
activité
di↵é
acti
Lecture for Chapter 16: Greedy Algorithms
I Soit . .I, anI} un ensemble de In activités
Problème
I Soit S :=
I Soit trouver
Problème
Soit
S{a=Soit
S,{a
a= S,,le
Soit {a
.a= .plus
.Soit
S,,{a
.a=
.Soit :.grand
.S,},{a
a=trouver
.un
Soit
.S
,},{a
I .IS,},sous-ensemble
1 21 le 21plus
.aensemble
=
un
.Soit {a
.aensemble
=
.Soit
.IS,},{a
.aensemble
=
.un
Soit
.S
,}de
I ,{a
.aensemble
=
.un
Soit
.n
S,}de
,{a
.aensemble
activités
=
un
.Soit
.I
nS,}de
,{a.de
.aensemble tâches
activités
un
=Soit
.I
n
S,}de
,{a
.aensemble
activités
=
.un
Soit
.S
n,}de
I ,{a 2n1 grand
.aensemble
activités
=
.un
Soit
.IS
n,}de
,{a
.aensemble
activités
=
un
.Soit
.n
S,}de
,{a
.aensemble
activités
=
.un
.S
n,},de
{a
.aensemble
activités
=
.un
2.n,}de
n1 2 ,{a
.aensemble
activités
.un
.n,},de
.aensemblen1 sous-ensemble
activités
un
. .n,}de
,.aensemble
activités
.un
.n},de
aensem
activi
unn}deen
ac
un 2n1 2n1 2 n1 2 n1 de tâches
16-2I définir aExample
iIdémarre
un NotesIforau
ordre temps sGreedy i Ietsur se termine au temps f2n1iI 2n1I 2n1I 2n1 2n1 2n1 2n1 2n n n
i“naturel” les iactivités
I Lecture
16-2Exemple 2i sorteda:16-2 sélection d’activités
Chapter 16: Algorithms
a16-2
16-2 16-2compatibles
I Lecture
16-2 démarre
Lecture I
iNotes démarre
a16-2 démarre
iNotes
Lecture for a16-2
au
LectureINotesdémarre
Chapter
for temps
a16-2
au
Lecture I
iChapter démarre
Notes
for temps
Lecture a16-2
au I
Example
16: iChapter
Notes démarre
stemps
for
Lecture aGreedy
i16-2au etfor
iNotes
16: Chapter démarre
stemps
ia
Lectureau
seI
Greedy
16-2
16: et
iNotes
Chapter démarre
stermine
temps
ia
Algorithms
for
Lectureau
seI et
iChapter
Greedy
16-2
16: Notes démarre
stermine
temps
a16-2
Algorithms
for
Lectureiau se
GreedyI
16: et
Chapter
Notes démarre
stermine
temps
Algorithms
for a16-2
iau
Lecture se
GreedyI et
iNotes
16: Chapterdémarre
stermine
temps
ia
Algorithms
for
Lecture au
Greedy
16-2 se
16:I et
iNotes
Chapter démarre
stermine
temps
a16-2
Algorithms
for iau
Lecture se
Greedy I
16: et
iChapter
Notes démarre
sftermine
Algorithms
for
Lecture temps
aGreedy
iau se
au
16: et
iNotes
Chapter démarre
sftermine
temps
Algorithms
for
Lecture aGreedy
temps
iau se
16: et
iNotes
Chapter démarre
sftermine
Algorithms
forLecturetemps
aGreedy
iau au
se
16: et
iNotes
Chapter démarre
sftermine
Algorithms
for
Lecture temps
aGreedy
temps
iau au
se et
iChapter
16: Notes démarre
sftermine
temps
Algorithms
for temps
iau
se
au
Greedy
16: et
Notes
Chapter sftermine
temps
Algorithms
for itemps
au
au
se
Greedy
16: etAlgorithms
Chapterforsftermine
temps
itemps
ause
au
Greedy
16: et
Chapter sftermine
temps
Algorithms itemps
ise
au
Greedy
16: et sftermine
Algorithmstemps
iseau
Greedy
16: et sftermi
Algorithitemp
iau
seetAlg
Greedy fte te
is a
I Deux S activités
16-2 by finish a et
time: Lecture a [Leave sont Notes compatibles
foron board]
Chapter 16: Greedysi soit Algorithms f  sChapter ,Greedy soit fChapter  sfor
I sélectionner
I Deux I Deux I16-2
les
activités
Deux
I16-2
activités
activités
DeuxI16-2 aIii 16-2
activités
Deux activités
et Deux
aSIi a16-2
Lecture j INotes
activités
et Deux
jLectureasont idans
a16-2 activités
et Deux
aby
jLecturesont
I a16-2
iNotes compatibles
activités
for et cet
Deux
asont
I
Lecture
Chaptera16-2
iNotes compatibles
activités
foret Deux
asont
jLecture ia
INotes
Chapterordre
compatibles
activités
16-2
for et
j16:Deux
asont
Lecture I a16-2
Chapter
iNotes compatibles
activités
foret
Greedy
j16:siDeux
asont
Lecture I a16-2
Chapter
iNotes pour
compatibles
soit
activités
for et
Greedy
j16:si
Deux
aAlgorithms
Lecturesont
IChapter a16-2
iNotes compatibles
soit
activités
fet
for
Greedy
j16: isi Deux
Lecture I
iautant
aiAlgorithms
sont

Chaptera16-2
compatibles
soit
Notesactivités
fet
for
Greedy
j16:isi
sDeux
aAlgorithms
Lecture sont
jI  j16-2
i,Notes
acompatibles
soit
activités
fet
for jsoit
isi
16:sDeux
aAlgorithms
Lecture sont
jI i,Notes
Chaptera16-2
compatibles
soit
activités
for fet
jsoit
Greedy 16: qu’elles
isi
sDeux
faAlgorithms
Lecture jsont
 j16-2
i,Notes
acompatibles
soit

activités
for et
fjsoit
Greedy isi
sfaAlgorithms
Lecture
16: jsont
jsi,Notes
Chapter a16-2 fjisoit
icompatibles
soit

activités
et
Greedy isi
sfaAlgorithms
Lecture
16: jsont
js
 ,ai
Chapter
iNotes fjsoient
compatibles
soit
et
for soit
Greedyisi
sfaAlgorithms
Lecture
16: sont
jsChapter
 ,aicompatibles
iNotes soit
 et
fjsoit
for
Greedyisi
16:safAlgorithms
Lecture sont
si ,aicompatible
jChapter
Notessoit
et
fjsoit
for
Greedy isi
sfAlgorithms
Lecture
16: jsont
s a,icompa
jChapter
Notessoit
 fjsoit
for isi
GreedysfAlgori
16: sont
s
jjChap,icom
Note
soi
fso
for
Gre isi
sfAj
16
Exemple Exemple
Exemple
Exemple Exemple :
i2 Exemple
1::2:sélection
estExemple :utilisée
2sélection
3Exemple
:2sélection
4Exemple
:2le sélection
Exemple :plus
d’activités
2le6sélection Exemple :plus
d’activités
2grand sélection
7Exemple :plus
d’activités
2legrand sélection
Exemple
:plus
d’activités
2lesous-ensemble
sélection
Exemple:plus
d’activités
2sous-ensemble
sélection
Exemple
:plus
d’activités
2sous-ensemble
sélection
Exemple
:plusd’activités
2sous-ensemble
sélection
Exemple
:plus
d’activités
2lesous-ensemble
sélection
Exemple :trouver
d’activités
2lesous-ensemble
sélection :plusd’activités
2lesous-ensemble
sélection :plusd’activités
2lesous-ensemble
sélection :plus
d’activités
2lesous-ensemble
sélection :trouver
d’activités sélection d’activités d’activités d’activité d’activ
sorted jfinish time: [Leave on board]
Un salle
Problème 2trouver
pour d’activités di↵érentesgrand sous-ensemble activités de tâches
Exemple Problème
compatibles
Exemple Problème
Example 22Problème::est sélection
:Problème
Ssélection
trouver
avec :Problème
trouver :Problème
trouver
acelles
le5Problème
: trouver plus
. d’activités
:Problème
adéjà
trouver
1le :Problèmetrouver :Problème
8trouver
3choisies 4grand
Problème
:Example 9trouver
5le grand
:Problèmetrouver
6le grand
Problème
:Example trouver 7le grand
Problème
: trouver 8grand Problème
:Example
de plus 9grand
:Problème
tâches
de trouver grand
Problème
:tâches
de trouver grand
:tâches
de trouver grand
:tâches
de plus le
sous-ensemble
grand
:tâchesde trouver
plus le
sous-ensemble
grandtâches
de plus le
sous-ensembl
grandtâches
de plus le
sous-ensem
grand tâches
de plus sous-en
grand
tâche
desou gra tâ
de
Exemple compatibles
Un Un
compatibles
Soit
I Example
salle
UnIcompatibles
salles 2 Example
Un
salle
compatibles
1 est Unsélection
=
Example
salle est
compatibles
2 {a
utilisée
Un
salle 1 ,1Example
Example
est
utilisée
compatibles
4
utilisée Un
salle 2 ,5.Example
est
utilisée
compatibles pour
UnsalleExample
compatibles
pour Example d’activités
.i8, Example
est
utilisée
pour
Un
salle
i compatibles
Example
n }9Example
di↵érentes
est
utilisée
pour
di↵érentes Un
2un
salle di↵érentes
compatiblesest
Exampleutilisée
pourUn ensemble
Example
salle
compatibles
11 di↵érentes
est
utilisée
Example pour
Un
salle
compatibles
13
Exampledi↵érentes
est
utilisée
activités
pourUn
Example
salle
compatibles
activités di↵érentes
Exampleest
utiliséede
activités
pour
Unsalle
Example est nExample
utilisée
activités
pour
Un salle activités
Exampleest
utilisée
activités
pour
Unsalle
compatibles
Example di↵érentes
estutilisée
activités
pour
Un
Example
salle
compatibles
Example di↵érentes
est
utilisée
activités
pour
Un
Example
salle
compatiblesExample di↵érentes
est
utilisée
activités
pour
Example
salle Example di↵érentes
est
utilisée
activités
pour Exampledi↵érentes
est utilisée
activités
pour di↵érentes
Example utilisée
activités
pour di↵érentes
Example activités
pour di↵érentes
Example activités
pour di↵éren
Example activité di↵é acti
Un Ssalle
SfaI
i
sorted démarreest by utilisée
finish
au time:
temps pour s [Leave
sby 1 di↵érentes
et[Leave 2 se on
4 termine board]
1 5 activités 8
au temps9 11 fboard] 13
Exemples
16-2 Un
Exemple :Lecture
salle
Soit
UnIIIIExemple
Exemple salle itrier
Soit
isorted
S3est
Soit
Exemple
sorted
:est
S
INotes
S16-2
S5by
=
= les
sorted
finish
S
utilisée
Soit
S
I{a for
7= by
Soit
:utilisée
{a 11S
I activités
sorted
finish
8S
Chapter
,,{aaa=by
Soit time:
Ssorted
,,9{a
aa22215:i,,pour
I ..S
pourfinish
a= S..by time:
ISsorted
.16:
Soit ,10,,{a
.2f1..:6isorted
.[Leave
sorted afinish
S
aa= .Soit .1time:
S sorted
idi↵érentes
Greedy
:,}}sorted
,11
nndi↵érentes
I {a .S aselon
finish
5=
by
by
.un
unSoittime:
n.1S
sorted
:,}sorted
I ,{aon [Leave
14finish
S by
.Algorithms
finish
aensemble
=
un
.by
Soit
n1.I
ensembleS board]
time:
sorted on
,}sorted
,8{a [Leave
finish
S
.finish by
aensemble
un
=
.by
16 stime:
Soitn1.9
S
I
board]
time:
sortedon S
:,}iactivités
time: ,activités
{a.finish (début),
[Leave
afinish
by
ensemble
=
.un
Soit
n.1S
board]
time:
sorted
:,}[Leave
I de
de
on
,[Leave
{a [Leave
finish
S
.finish by
aensemble
=
.unSoit .1I n
S board]
time:
sorted
:n,}[Leave
de,{aon [Leave
finish
S
.finish by
aensemble
activités
=un
.by
Soit on
1.14
activités I S board]
ntime:
sorted
:,}[Leave
de,{aon S [Leave
finish
.finish
aensemble by
activités
un
=
.by Soit iI
.n
S selon
board]
time:
,on
sorted
,}[Leave
de {a S[Leave
afinish
.finish byI
ensemble
activités
=
.un Soitn.1S
board]
time:
sorted
:n,j}[Leave
de,{a on [Leave
finish
S
.finish
aboard]by
ensemble
activités
=
.un Soit 1.I
S board]
time:
sorted
:n,}[Leave
de
,{a f.finish
on [Leave
Sfinish
.by
aensemble
activités
=iun Soit .time:
n
Ssorted (fin),
,board]
}[Leave
de on
,sorted
{a a[Leave
finish
.finish by
ensemble
activités
=
.un .S n,board]
time:
}[Leave
,de on
{a [Leave
afinish
.finish
ensemble.n,board]
bytime:
activités
=
.un }[Leave
de
,{a onselon
[Leave
finish
.finish
aboard]
ensemble
activités
.un n,}board]
.time: ,de on
[Leave
.finish
aensemble
activités
un
.by n,board]
.time: ,on
}[Leave
de [Leave
.finish
aensemble .nboard]
activités
.un on
}sorted
,de [Leave
aensem
activi
un nboar
}[Lea
de on
en
ac
un
11ai I:S Exemple 33Exemple1:4,Exemple Exemple a,Exemple 73Exemple Exemple :Chapter Exemple Exemple Exemple Exemple Exemple fi2n1I: Exemple Exemple f1:j 2n1:si 2n1 2n1 2n n n
23 by 7finish sorted by 10
time: sorted by n11
time: on board] on 16 board] on non board] on board] on board]on on [Leave board] on board] on [Leave board]on bo tio
Soit
Deux =
activités {a .et SLecture
S
j nsont }Notes S un2 S 2
ensemble
compatibles
for
S 2 S 16:
2
de S
Greedysi2
nsorted soit
S 2
n time:
activités sorted
Algorithms
S time: sorted S by 2time:
sI
sorted
, soit
S by time:
2 sorted S by time:
2n S by time: sorted S by time: sorted S by time: sorted S time: sorted S bytime: finishbytime: fin by
I ia SoitI démarre S 2démarre
=a {a
démarre
aau , a
démarre
temps
a au , . .
démarre
temps
a au . , a
démarre
s temps
a au }
et un
démarre
s temps
aau
se et 8s1ensemble
démarre
termine
temps
aau
se et 9aiau
démarre
s termine
temps se et démarre
s termine
temps
a au
se et dedémarre
s termine
temps
a au se net activités
démarre
s termine
temps
a au
se et démarre
sf termine
temps
a au
se
au et démarre
s f
termine
temps
atemps
au se et démarre
s f termine
temps
a au au
se et démarre
s f termine
temps
a temps
au
au
se et démarre
sf termine
temps
temps
au
se
au et s ftermine
temps
temps
au
au
se et sf termine
temps
temps
ause
au et sftermine
temps temps
se
au et sf termine
temps
se
au et sftermi
temp
au
se et 8f9tete sa
f16-2
i − si (durée),
16-2 16-2 16-2 16-2
I aii démarre
i
Soit
Lecture
a 16-2
Lecture
I Lecture
Problème
i démarre
Lecture
16-2S
iNotes
Notes 2 nombre
1=i I
:activités
i
Lecture
16-2 forau
2
{a
Notes
trouver
1
for i 1
Lecture
au
1
I
i
16-2 4,3
Notes2a
Chapter
for
Chapter1temps
i 2
Lecture
16-2
temps
2
I5
i 4
,3 .2
Chapter
Notes
for 1 de
.
Lecture i i
16-2I
.
16:
16: 5
i 6 4 ,3
Chapter
Notes 2
forssa1Greedy
11
Lecture ii conflits
Greedy
16-2 n
iGreedy
n
I
i
16:5 6et
} 4 7
Notes
Chapter
et
2
for 1 un
i
LectureiseI
Greedy
16-2
16:5
i
se
6 4 7
Notes3
Chapter 8
2 i
Algorithms
for i
Lecture I
termine
ensemble
i
Greedy
16-2
16:5
termine
Algorithms 644 73
Chapter
Notes 82 1
9
Algorithms
for
Lecturei
16-2avec
5
GreedyI5
i
16: 64 73
Chapter
Notes 8
2 19
Algorithms
for i
i
Lecture
16-2au
6
GreedyI
i
16:
au
5 6 4 7
Notes3
de
Chapter8
2 19 itemps
Algorithms
for
Lecturei
Greedy
16-2 d’autres
16:I
7
temps
5
i 6n 4 7
Notes 3
Chapter 8
2 19
Algorithms
for i
i
Lecture
16-2
Greedy I
activités
16: i 5 6
8 4 7 3
Chapter
Notes 8 2 1f1fi657ii894321657i894activités...
9
Algorithms
for
Lecture ii
Greedy16:5
i 6 49
Notes7
Chapter38
2 19
Algorithms
for
Lecture i
i
Greedy16: i5 6 4 7
Notes 3
Chapter 28 1 9
Algorithms
forLecture i
i
Greedy I
16:i5 6 4 7
Notes 3
Chapter 28 19
Algorithms
for
Lecture i i
Greedy i5
16: 6 4 7 3
Chapter
Notes 8
2 19
Algorithms
for i
Greedy
16: 5 6 4
Notes
Chapter 7 3 28 9
Algorithms
for i 5
Greedy
16: 6 4 7 3
Chapter 8 9 i
Algorithms
for Greedy
16:5 6 4 7
Chapter 8 9
Algorithms ii
Greedy
16:5 6 7 8 9
Algorithmsi
Greedy
16: 6 7 8 9
Algorithii
Greedy 7 Alg i6
aai I55iile aiplus 9grand sous-ensemble 1de 1tâches
16-2 Notes for Chapter i 16: i i 2 1 i 3 2 1
Algorithmsi 4 3 2 1 5i 4 3 2 1 6 5
i 4 3 2 1 6 5 7
i 4 3 2 1 6 5
7i 8 4 3 2 3 2 1 6 57
i 894 3 2 1 65
7 i
8 9 4 3 2 1 6
5
7i 8 9 4 3 2 1 657
i89 4 3 2 1 657
i89 4 3 2 1 65
7i8 49 3 2 1 657
i8 49 3 2 1 6578 49 3 2 57
Is aaDeux 1s1Deux 22s1Deux 44activités
1116-2 5i8 94activités 11 13
16-2 siDeux
I ExampleiI
Lecture ii démarre
i INotes
démarre 16-2 i I16-2
activités for iau
21sDeux
auI 2s1temps
4activités
Chapter Deux
temps 4activités
2et
116-2et ssDeux
s1Lecture I
i16: 81aa16-2 s1sLecture
4activités
2et
jjs 1sDeux
aGreedy
iisont
I a1et
5i8Notes
sont 16-2
et 22et
j1
sLecturese
Deux
aisont
I a116-2
94compatibles
5i8Notes
se 11 js termine
activités
22et Deux
aisont
11Lecture
4compatibles
for I 1a9416-2
compatibles
5iChapter
81Notes
Chapter
termine
Algorithms activités
11 2et
4for
13js Deux
ai55sont
1Lecture I 1a416-2
9compatibles
4activités
5i8Notes
Chapter 11
for22et
13 js Deux
116:
Lecture au
a8i58sont
I a116-2
5i8Notes
Chapter
au 1113
for 1s16:
Greedy a8i5temps
94compatibles
4activités
22et siDeux
si
Lecture
jGreedy sont
I
temps a116-2
94compatibles
5i8Notes
9Chapter soit
4activités
11 et
2213
soit
for js1
Greedysi
Deux
16:a8i11
Lecturesont
I
11 1a9416-2
5i8Notes
Algorithms
Chapter compatibles
soit
activités
11 f13
4for2et
fjs
Greedy isi
16: fDeux
ai811
Lecture
f iisont
I
5i13
 1a16-2
8Notes
Algorithms
Chapter 9compatibles
soit
activités
112f13
et
4Greedy
for js si
16:sDeux
ai811
s
Lecture
i1 sont
I5i8,Notes
Algorithms a116-2
,
jjChapter 94compatibles
soit
4activités
11 2f13
foretjsoitsi
ssDeux
1ssoit
Greedy 16: a8i11
Lecture
i1 sont
jI5i8,Notes
1a16-2
Algorithms
Chapter 94compatibles
soit
4activités
11 22f13
for etsoit
js
Greedy isi
116:sDeux
fafsi811
Lecture jsont

5i18,Notes
Algorithms
Chapter1a16-2
94compatibles
soit
4
activités
11
 22et
for f13
jsoit
Greedy isi
sfa811
1Lecture
16: jisont
js
s
5i181,Notes
Algorithms
Chapter a16-2
i49compatibles
soit

activités
11 2et
4forf13jsoit
Greedy isi
sfa811
Lecture
16: jsont
js
 ,a1i944
5i18Notes
Algorithms
Chapter compatibles
soit
et
11f13
forjsoit
Greedyisi
sfa811
Lecture
16: sont
jsChapter
 1,ai94compatibles
5i81Notes
Algorithms soit

11et
f13
forjsoit
Greedyisi
16:sasf811
Lecture sont
s5i1,a94icompatible
8Notes
Algorithms
jiChapter soit
et
11fjsoit
13
for
Greedy isi
sf811
Lecture
16: jsont
s1a,4i9compa
8Notes
Algorithms
jChapter soit

11fjsoit
13
for isi
Greedysf811
16: sont
s1
Algori
jjChap,9i4com
Note
soi
11fso
13
for
Gre isi
sf8519A1j
16
16-2 I Deux
Lecture 16-2
activités
Notes
16-2 for Chapter a et Lecture
Lecture 16: a 1 i sont
Greedy Notes
Notes 1s compatibles
for s
Algorithms
for Chapter
1 2 1 s 1 16:
1s16: 1 Greedy1s si 9 1 soit 1 s Algorithms
5
9 1
Algorithms 2 f 1
i s 5
913 1  4 2 s 5s913 1 , 2 soit 59
13 1 1 5
9 f
13
j  1s 5
913 s i 2 1 s 59
13 2 1 s 59
13 2 1 5
913 2 1 s 59
13 2 1 59
13 2
Montrercompatibles
par des i contre-exemples
55f3 775f3 8875f3a99i875fet j3 11
:que 9seul le tri
i 16 j
selon j
f8grand ifonctionne
i
f f 33 16-2 i
10 i i 14 i i i i i i i i i i i i
I fiDeux
Problème
IProblème
i Problème activités
:Problème
trouver
:Problème
trouver
i :Problèmetrouver le 3ffExample
Problème
:Example trouver
plus
ile
8aa7:Problème
3trouver
plus sont
9le 8granda55 7
7:Problème
3trouver
plus
i le
8grand compatibles
:Problème
55f33ftrouver
plus le 5f16
sous-ensemble
grand
7Problème
3f3trouver
plus
989le
i sous-ensemble
8grand
7:Problèmetrouver
plus le
sous-ensemble
8grand
Problème
7:16 si
trouver
plus
a5
9le 7:soit
sous-ensemble
8grand
Problème trouver
plus 89le
sous-ensemble
8grand 3fff10
Problème
7:5f5de trouver  9ss16 7,:,tâches 3soit 9f16  s8sgrand
iplus
9lesous-ensemble
8grand
:Problème
7tâches
5de trouver
plus 9le
jsous-ensemble
jgrand
87Problèmede trouver
plus 9lesous-ensemble
8grand
7:tâches
de trouver
plus 9le
jsous-ensemble
Deux i10
Lecturei9 5f[Leave
j3 i10 11 Notes 5f3f i10 911 714 for i10 88
9Chapter
11 714516 i910 11 714 55f3f10
16 10
316:i910 11 71455f3f10
Greedy 9i11
10 11 714 55f
16310 91014 11
Algorithms 714 16 10 11 714 5f16 3f10 10 11 14 5f
516 3f10 10 11 714 5f
516 310 f10 j11 7:itâches
714 5516de
3f10 trouver
plus
10 98le
sous-ensemble
11 :7i5itâches
714 5de
16 trouver
plus
109le sous-ensemble
11 8grand
77 tâches
14
516de plus
10 9le sous-ensembl
8grand
11 tâches
714
516de plus
10 9lesous-ensem
11grand
7145tâches
16de plus
910 sous-en
11grand
714 tâche
5de
16 sou
811gra 5tâ
714 de
16
Problème ::activités
trouver ai time: et isont compatibles si soit  soit 
S sorted i 16-2
by finish ile plus
Lecture jf grand
Notes onfor i8 sous-ensemble
board]
Chapter 16: i8 311
Greedy i8 3f11 i14 iAlgorithms de 311 ii14
916i8 tâches311 i14 i8 11 i14
916i8 3f11 i14 i8 311 14
916 f
310 1114
916
i8 f310 1114
916
i8 3f
10 1114
916
i8 f3101114
16
i8 310 11
14
916 10
1911
Problème
Exemple
Example
Example Example
: trouver
Example Example Example ile
Splus sortedExample grand Example
by finish Example sous-ensemble
Example time: Example [LeaveExample Example on Example de
board] tâches
Example Example Example
ProblèmeExample
compatibles
compatibles
Problème
compatibles
Example compatibles :: trouver
compatibles
trouvercompatibles compatibles le
a
compatibles
le 4 plus
Exampleplus
Example
Example compatibles
Example grand
compatibles
grand Example compatibles
Example sous-ensemble
compatibles
sous-ensemble
Example a4
compatibles
Example compatibles
Example compatibles
Example de
compatibles de
Example tâches
compatibles
tâches
Example compatiblesExample Example Example Example Example Example Example
Si sorted
S
Example S1 sorted 2Sby 3S
sorted
finish 4S
bysorted finish
bytime: 5S
sorted finish by itime:
6 [Leave
sorted Sfinish
[Leaveby time:
sorted 7[Leave
finish
S bytime:sorted on3on [Leave
8bytime:
finish
S board]
sorted on [Leave
9by
finish
S board]
5time:
sortedon [Leave
Sfinish
by board]
6time:
sorted on [Leave
finish
S by 7time:board]
sorted on [Leave
finish
S bytime: board]
sorted on S [Leave
finish by board]
time:
sorted on S[Leave
finishbytime: board]
sorted on [Leave
finish
S bytime: board]
sorted on [Leave
Sfinish bytime: board]
sorted on [Leave
finish by board]
time: on [Leave
finish
bytime: board] on
[Leave
finish board]
time: on
[Leave board]
time: on[Leave board]on
[Leave boar on
compatibles
Exemple S
Exemple
sorted
sorted
Exemple
by
by finish
finish time:
time: [Leave
S1 :sorted 2Sby on bya:board]
4board]
:8[Leave 9sorted
1 ::: Exemple : Exemple :a1Exemple
2 : Exemple :8sorted Exemple Exemple :sorted Exemple aExemple :sorted
aExemple :[Leave Exemple a:[Leave5Exemple Exemple a:5 aExemple :sorted 9Exemple :[Leave :[Leave :[Leave
compatibles SExample finishS sorted
2 finish S by time: afinish7S by time: sorted
[Leave finish
Sby time: sorted finishSby on
time:
on sorted board]
finish S by
board] on[Leave
time: board]
finishS aby on 7a[Leave
time: board]
finish Sby on
time: sorted board]
finish S by on
time: sorted
finishboard]
Sby on
time: sorted finishboard]
Sby on a[Leave
time: sorted
9 finishboard]
Sby on[Leave
time: sorted board]
finish
S by on[Leave
time: sorted board]
finish
Sby onsorted
time: [Leave board]
finishby on[Lea
time: bo
fin by tio
Exemple
Exemple Ssiii sorted
S sorted
1 i
2by
2 1 by
i 3
4finish
2finish
1 i 4 3 2 1 i 5
5 SS
time:
time:
43 2 1
Example
s
i 5 6 4
sorted
sorted
3 2 [Leave
[Leave
1 1 i 5 6 4
aa9
7 3 2
5 by
52bya4
1 i 5 6 4 7 3
11finish
5finish
on
on
8
2 1 i 5 61board]
board]
4 73 513
82 1
9 i
time:
time:
5 5 64 73 5 8a
8
2 19 i 5 6 4
[Leave
7 3 5 a9
8
2 19 i 5 a5 a11
5 6 4 7 3 8
2 19 i
on 5 a5 board]
5 6 4 7 3 8 2 1 9 i 13
5 6 4 7 38
25 a5 a5 a5 a5 a5 a5 a5 a5 a5a5 a5a5 a5a5 a5 a5 a5a5 a
19 i 5 6 4 7 3 28 1 9 i 5 6 4 7 3 28 19 i 5 6 4 7 3 8
2 19 5 6 4 7 3 28 9 5 6 4 7 3 8 9 5 6 4 7 8 9 5 6 7 8 9 6 7 8 9 7 89657
Exemple
Exemple 1 : a522 733 844 595 Sii10 S i sorted
6a6sorted 77a2211by by finish
8finish time:
91955itime: [Leave on board]
siii s1i : 2s11i 4321si 1442s1iaa514442s1fi iai58614432s131i a58149472521si a5814911
f i 1
3 11 i 11 i 33 14 2 81 i 4 4 3 a2 16 4 3 2 1 6
6a5
i 343 [Leave
2 1 6 5 7
i
7 4 3 2 1 6 5
7i on
8
8
a 4 3 2 board]
1 a6 5
7 i869
4
9 3 2 1 65 7i
8 94 3 2 1 6 57
i 894 3 2 1 65
7 i
8 9 4 a3 8216 5
7i 8 9 4 3 2 1 657
i89 4 3 2 1 657
i89 4 3 2 1 65
7i8 49 3 2 1 657
i8 49 3 2 1 6578 49 3 2
47328s1i a588414911 41326s19aia95a454814911 4132s110 a6a
i 45 814911 21sai11
413 47a5 814911 4213 s1ia14 a45 88814911
413 2s1iaa416 58914911 4213 s1iaa45814911 4213 1sai 4a5814911 4213 s1iaa45814911 4213 1aa45814911 4213aa458149411 13aa45814911 13aa4584911 13a48911 13a4 911 13a
ssii 11 22 443 114 55 sssiiii886 111si 9972221si 4411 311 281si1144213 1319
s555i1421s8856i1421s8599i71421s811 59i18421s811
11 5913
i19
13 421s811 5913
i1421 s811
5913
i1421 s811
5913
i1421 s811
5913
i1421 s811
5913
i1421 s811
5913
i 1421 s811
5913
i1421 s811
5913
i14218 11
5913
142 85191
ffssiiii f3113i 5f25232i 747745f33iaa28818175f34i a99595875f3ff5si10
0i9
i10
875f3f3361i110879955f3f32i10
911
ia11
911
81474311
55f333fia10
a911148145f13
71643ia10 5911 814716f3f10
55 8610
89
11
814 5f3f10
7616 97911
9ia10 75f
871416 310 11
1092811
88 7f
1416
53f10 13
108989714
911 75f
16
53 10
92a11
a10
ai14 87145f3
7516 11 a10
89
1175f16
814 a3 3f12 1098211
8714
75516 3a13 109211
8714
7516
514 1092911
a8
77
14 516
915 109911
8714
516
16 10
982911
714516 9a1011
71416 82111416
f 0i 31 5 2 2 f s ia8
10 2 3 1 11
25 2527 ia27714 11
47414 82182127516
8 ia8 f
939
13
16 959i5a82a27a75710 310
i9
10
a8
8ia2a75
2711
311
1111i9a8
9
2a75
271214
3f11
i14
9a11
ia8
14
11 a2775
13 311
i14
9a16
13
16
ia
16
2a
13
af 10
311
79 16
78
2 714aia9a29715aia9a
af 10
311
7i14
916 2 75
2 716aia9a
1011
7i14
9a16 27 a
f10
311
714
9a16
ia8 9a
27 a
af310
11
714
9a16
ia8 9a27 a
af
310
11
714
9a16
ia8 2a f
a3
10
92 7 ai 9a7 a
11
714
a9 16 af
310
11
71416
i8
29a 5a310
9 7 a9a7 a
11
714
9a16 975a10 1791a1
i
f
fii 33 a 55 77 88 99 ffMaximum-size 10
10 33 1111
aa1515 7714
14 16
16
88aamutually 99 a1 a10 a3 acompatible 11a5a1 a314 a16 aa;8 aa
ai 5 a 1 1
a11 a1 a1 a1 ai 33a1 a3a1 a3a1 aa3a661 aa3a61 aa3a61 a3aa61 aa88a3a61 aa8a3a61 aa8a3a61 aa83a61 aa8a3a61 aa83a61 aa83a6374 10 3 1 a 11
3 14
a a 1 aa 63616set:
a 1 aa 6 3 fa a 1 a
1a ;
6 3 a a3 1 ;a 6a
3a 6
8 1 a 63a
8 8g.
a 1 a
a 6 3a 8a 1 aa a a a a
aa83a6 aa8a3 6 aa83a6 a8a6 a63
6 3 8 1 63 8a 1 aa 63a 8a 1 a 63a a
8 1 a
Maximum-size
Résolution de problèmes mutually compatible set: fa1 ; a3 ; a6 ; a8 g.
a4 0Not 1unique: aa5 2 a53also a54 fa a42 a55; a5a;65a7aa5;a7a59 ag.5 8a5 a59a5 a10 5 a5 a11 5 a5 12 a5 a5 13 a5 a5 14 a5a5 15a5a516a5a5 a5 a5 a5a5 a
987615 98716 615 098716 615 98716
6515 987616
515
00Not110unique: 33210also43210 fa2543210; a565643;210 a7a;5765743210a9 g.8765438210 98765439210 10
0 10 5210 3210 43210 543210 6543210a576543210 87654321098765432110 09876543211 110
0987654312 211
110
098765413 312 211
1010 9876514 413
312 2111
010 514
413
3212 111
010 514
4313 212
111
10 5414
313 21211
1010 414
313 12
2111
10 414
13
321211
10 9
2210 10
9876543210 11 10911
876543210 5 12 1112
10
9876543201 13 12
11
1098713
6543102 14 13
12
11
109814
76542103 15 14
13
12
11
109876515
32140 16 15
14
13
12
11
1098764316
2501 16 15
14
13
12
11
10987543162 16 15
14
13
12
11
1098654723 16 15
14
13
12
11
109765384 16 15
14
13
12
11
10876945 16 15
14
13
12
11
1098756 16 15
14
13
12
109867 16
11 15
14
13
11
10
12
978
a a
a2 aa4 a4 a4a55 a4 aa24 aaa44 4a7 aa4 4 aa4a554 aa4 4 aa4 4 aa7a4 49 a4a4 aa4 4 aa4 4 aa4a49 aa4 4 aa4 4 a4 a4 a
a44 Maximum-size
Maximum-size
OptimalMaximum-size
Maximum-size mutually
Maximum-size
mutually
substructure Maximum-size
a4mutually Maximum-size
of compatible
mutually
compatible
Maximum-size
mutually
activity compatible
Maximum-sizemutually
compatible
selection set:
Maximum-size
set:
mutually
compatible
Maximum-size
set:
fa fa
mutually ; ;fa
compatible
1Maximum-size
1 set:
a a
mutually
3compatible
1;Maximum-size
3 ;afa aset:
6mutually
3;6 1;a ;aa8a
;Maximum-size
compatible set:
fa6g. g.1;aMaximum-size
8mutually
3;compatible
;a8fa set:
a6g. mutually
;compatible
3 1;aMaximum-size
set:
;a8fa
a g.mutually
6 3;compatible
1;aMaximum-size
aset:
;a8fa mutually
6g. 3;compatible
1;aMaximum-
;a8a set:
fa6g. mutually
3;compat
1;a;a8faset:
a mut
6g.;com
3 1;a;a 8
Résolution
Résolutionde problèmes
Résolution
de Maximum-size
Résolution
problèmes
de
Résolution
problèmes
de
Résolution
problèmes
de
Résolution mutually
problèmes
de
Résolution
problèmes
de
Résolution
problèmes
de compatible
Résolution
problèmes
de
Résolution
problèmes
de
Résolution
problèmes
de set:
Résolution
problèmes
de
Résolution
a4problèmes fa
de
Résolution ; a ;g. 374
Maximum-size
Maximum-size
Maximum-size
Maximum-size
Maximum-size
a mutually
Maximum-size
mutually
Maximum-size
compatible
amutually
Maximum-size
compatible
mutually
Maximum-size
compatible
a mutually
Maximum-size
set:
compatible
a aa32problèmes
mutually
Maximum-size
set:
compatible
fa ;de
Résolution
1mutually
fa
a a problèmes
Maximum-size
set:
compatible de
Résolution
aa6aa326problèmes
3;mutually
;Maximum-size
set:
compatible
afa ade
aRésolution
;1;mutually
;Maximum-size
set:
fa problèmes
compatible
aa8a686a3g. a de
;mutually
Maximum-size
;aset:
acompatible
fa
a78a
g. problèmes
aade
;;mutually
afa
a problèmes
;Maximum-size
set:
compatible
a6ag.;1;mutually
Maximum-size
;aaset:
compatible
afa
a g. a;1;mutually
;aaset:
compatible
afa
a78aa6a3g. ;;mutually
a;aset:
compatible
afa
a g. 374
;1;mutually
;aset:
a compatible
afa
a g. ;374
;1mutually
;aaset: ;1;374
compatible
afa
a g. ;aset:
compatibl
fa
aaa78aa63g. ;;a 374
;set:
comp
fa
aaaaa6g. 374
;1;;a se
afa
aa78aa6
Optimal a1 substructure
aa2 a24 Not
a 4 a23 of aactivity
1
unique:
Not 2 unique:
Not aa2selection
also
a2 also
a
unique:
Not 2 fa
6fa
a
2aalsoa242aa2;7;also
unique:
Not 2
aunique:
Not
fa 1
a55a2;a;2;a7aalso
fa a32a1
775;;2;a
aunique:
Not 2a fa
a
9 g.
;a79also
unique:
Not
7g.
5; 2 8a
;a 2;a
79also
fa
7g.5; 22;aa12;a79also
aunique:
Not fa
ag.
7 ;6a3229;aa12;a79also
a75aa
aunique:
Not fa 78a
aunique:
Not
7g.5;2
3
2a
9;a2;a
79also
fa
a 78
7g.
aa6a329;a
unique:
Not
5; 2
a2;8a
79also
aNot
fa
7g.5 ; 229;aa21;a79also
unique: fa 78a
g.
7
a6a3
aunique:
Not5;a
29a
9;9a
2 2;a
79also78a
a6a3
aunique:
faNot
7g.5;2
92a
9;a
2;a 79also78aa63
unique:
aNot
fa
7g.
29a
5; 29;a;a 79also
fa
aNot ;2299;aa1;a
unique:
7g.5 also
79fa
a 78 23
unique
g.
7
9a
5;2;9a;a als
79fa
a 7g. 5;
a22 2a77 7 79
a379aa75g.9a;2;Not
9 2 9
Not
Not unique:
Not
unique: Not
unique: also
Not
unique: Not fa2Not
unique:
also ;also
unique:fa
Sa52;Not
unique:
;also a
fa
aD ;;Not
75a2 aafa
unique:
;also 75g.
a99faa;2;Notaunique:
;also
afa
a92a7g.;2;SNot
25a unique:
a ;also fa
a9W7g.
a 2;Not
5;f unique:
;aalso
fa
aa
a9!g.a;2;Not
75 sunique:
;aalso fa a;2;Not
a975g.
aa < unique:
a ;alsofa
aa 5a;2;Not
97g.
fa ! unique:
a ;alsofa
aaa 5a;2;Not
a97sg. gunique:
;aalso fa
aaaa unique:
;also
aafa a g.;2;Not
975 unique:
also
a ;a fa 5a;2;unique:
g.
a97[Leave ;also
aaafa a;;;also
aa693a75g.
2 afa
aaa ;also
a9a7a5g.9a;2;board]
on aaaafa
a9a75g.a;2;1a fa
;aaa9a7g.
5a;2;;a aa
aa g.a;;aaa9a7g.a; aa9
9a75
aa1 a1 aaa22 1 a1 0aaij3a1 1 a3aaa11112 a3a11k3 aa2a3aa6141 aa3aa561177iaa33a3 a3a6611 k3a3a7a611 aa3a8k8a3a611aaa663a689a3aj611 aa610 7aaa 9 1aa11 63 a1 a63a
aaa88a8a113 aa8a 114a63aa8a9 115a63a 8a16 a63aa8 1 a63a a8 1 a63 a8 1 a63
3a
961 aa83a61 12
0S 1 Da112 fa3 2 4S W f 5 a33!6 sD 7<activities 14on 15
8
16 8a3861 83 61 83 6 83 6 83 6 83 6 8 6
ij k Optimal
i Optimal
kaa1Optimal fk8Optimal
substructure
substructure !a669Optimal
substructure g 10Optimal
ssubstructure
j that a
start 11 after
3of activity
substructure
aof activity
Optimal
12 [Leave
substructure
of
a88 a
activity
Optimal
13 finishes
substructure
of selection
selection
activity
Optimal
isubstructure
a6of selection
a activity
Optimal
substructure
of board]
selection and
activity
Optimal
substructure
of selection finish
activity
Optimal
substructure
of
a8 selection
a activity
Optimal before
substructure
of selection
Optimal
activity
substructure
of selectionaof
Optimalj starts
activity
substructure selection
activity
Optimal
substructure
of : of selecti
selection
Optimal
activity
substruct activit
subst
of se acs
aa1 a
00 a33 110 1210 33210 mutually aa44366210 5543210 3 6654compatible a
3210 776543210a88788654321099687set: 65432110 010 98fa76543211 111
10
0;98a
7654312 212
11
1;10
0a9876584;13
313 12211
1a
010 9876g.
514
414
13
312 2111
010987615
515 14
413
3212 111
01098716
15
616
514 4313 098716
212
111
10 615
5414
313 212
11
101098716
6515
414
313 12
2111
10987616
515
414
13
321211
10
9
5435210Maximum-size
2
Optimal
Optimal
00 Optimal
Maximum-size
1
2102substructure
101 DOptimal substructure
Optimal
32130substructure
activities Optimal
432410substructure
mutually Optimal
that 0substructure
of
Optimal
start activity
654632101substructure
activity
ofOptimal
compatible substructure
activity
7657432102after of Optimal
f8 selection
76854321i0substructure
aactivity
selection
iofsOptimal
49 substructure
activity
set:selection
of
8796543k210finishes Optimal
10
510
faactivity
selection
of
611 Optimal
10
11 ;fsubstructure
9876543210andactivity
selection
k 12
a 7of
;Optimal
12
11
10
assubstructure
activity
selection
9876543201finish8of
j ;13
13
12
11Optimal
10
a activity
selection
g.of
14
13
12Optimal
9before
11
10
14 10activity
selection
of 15
14
13Optimal
12
11
10
15 aactivity
11selection
jof
16
15
14
13
12
16 Optimal
3
11
10 substructure
12 activity
9876432501startsselection
6of
16
15
14
13
12
11
activity
8selection
: of
16
15
14
13
12
11
activity
selection
of16 15
1415
13
12
11
10
9765384374 activity
selection
of 16
15
16
14
13
12
11
10876945 activity
selection
of
16
15
14
13
12
1198756 activity
10 selection
of
16
15
14
13
12
109867 activ
11 sele16
15
14
13
11
10
12
978
0 1 2 3 4 50. . . 61 72 38 9 510 1611 37 12 68 1389 1410 . . .1511 16 13 14 15
Not
55S Sunique:
1D
Maximum-size
0ij 6Maximum-size
Maximum-size D
2fa
S also
S2
Maximum-size
ij kk3 D
fa SkS449fa
2ijmutually
88Maximum-size S2 WD
fa
Wijf fSk;5i10
Maximum-size
mutually 2mutually a2
S !
Wfa
D
!ijf
;Scompatible
aiMaximum-size
5 6ksa
mutually Sk72
!
Wfa
D ;<
skMaximum-size
compatible f<a
7S si12
mutually f
Sf
compatible
9k g.
2
!
D
Wkij<
fa kf S
Maximum-size! !
si13
8mutuallyS2
f !
WD
fa
compatible sijset:
<9sjf
Maximum-sizeSj!gsi14
mutually S2
gf !
Wfa
compatibleDsfa
< jfS!
Maximum-size
set:
10 gsi115
mutually f;;2
S
compatible!
Wfa
D skfa
<jf
Maximum-size
11 set:
a S !
gsi116 S;12
;;kf
mutually
compatible a2
!
D s[Leave
Wkfa
fa <
Maximum-size
12 jf
set:
a S !
[Leave
mutually S
f;a2
;compatible
13 !
WDsij[Leave
sgi;akMaximum-size
fa <
set:
fa
a ;!
jf
g.S
mutuallyon
gsi1;a14
S
f ;a2
compatible !
D
Wfa [Leave
son<
Maximum-size
set:
fa
a jf
6g. S board]
;!gsi115
mutually on
S
f
compatible ;a2
!
D [Leave
W8sijkfa
board]
fa
;aMaximum-size
a <
set: jf
g. Sgs16
board]
!
mutually on
S
f
;compatible
16
i1;a ;2a!
D sij[Leave
W8kfa
fa
Maximum-size <
aset: jf
6g. S board]
!
mutually Sfon
;compatible ;2
sg1i;aMaximum- !
WD
afas[Leave
a < jf
set:
fa
6g. S board]
;k!gsi1;af
mutually
compat on;2
a!
D
Wfa s[Lea
< jf
set:
fa
a6g. S
mut !boa
;com on
sgi1;akf ;2
!
fW8s
a
j set: fa 86g.
00 11 22 33 4 ij 7 i11
;6ag. ;a8a6a3g. 63;1a8
a7 ij k k k
a13 k k k kij k k ij 3 k ij6 k k 3k k 8k ij 3 k k 6 3 k k 3 k k 8ij
k 3 k 8k 3k
Résolution
Résolution
de
Résolution
problèmes
deRésolution
problèmes
de
Résolution
Maximum-size problèmes
de
Maximum-size fde
Résolution
problèmes
Résolution
i problèmes
Maximum-size de Not unique: also fa ; a ; a ; a g.
Maximum-size
s4Résolution
k problèmes
Maximum-size
mutually de
Maximum-size
mutually 6Résolution
Résolution
2Maximum-size
5mutuallyfproblèmes
problèmes
de de
Maximum-size
compatible 9 smutually
Résolution
i problèmes
kmutually de
Maximum-size
compatible mutually
Résolution
jMaximum-size
compatible 9Résolution
problèmes
de
mutually
Maximum-size
set:
compatible 10
problèmes
mutuallyde
Résolution
k problèmes
Maximum-size
set:
compatible
fa compatible
11
de
Résolution
mutually
Maximum-size
set:
compatible
fa 12
problèmes de
Résolution
mutually problèmes
Maximum-size
set:
compatible
fa de
mutually
Maximum-size
set: set:
Résolution
problèmes
compatible
fa g. 14
de
mutually
Maximum-size
set: fa
compatible
fa g. 15
1de
problèmes
mutually
Maximum-size
set: problèmes
1compatible
fa 16
a;13;mutually
Maximum-size
set:
compatible
fa 6;mutually
set:
compatible
fa 8;1g.
g. mutually
set:
compatible
fa g. 374
mutually
set:
compatible
fa g. 374
mutually
;asset:
compatible
afa g. 374
;asset:
afacompatibl g. 374
;sset:comp
afa 374
se
Résolution de Résolution
problèmes
Maximum-size
Sijij SD
de problèmes
. . . ij SD
Maximum-size fakkSD
ij fa
ij
mutually
2 mutually
SD
k 2W fkSNot
fa
ij S iD2W!fS
fa compatible
D
is 2 7
kW!f
fa < D 2
kWf
fa !f
Sunique:
is <S
D fa 2 S W f ! s < f ! s g
D
compatible
kunique:
Not
Maximum-size
ij
Not ij
unique: k activities
activities
Not
ij kalso
also
k siD
!2
kWf
fa set:
!mutually
f<
Ssfa
activities
unique:
Notij kalso
fa D
jis !
2kthat
fagWf
!;;f
jactivities
set:
unique:
Not ij that
2 S
k<sfa
also fa
. D
is
jfa!
2
fagW2f
! 1
activities
.
ij
5start
that
aaunique:
Not k start
.
;;1;1aa
;
;
fk<
Ssfa
also
a
aa
D
7jis!
;2
fa 3
g2W3f
! 1
activities
a;kstart
;unique:
Not
compatible
ij
5 that
;
after;
;af<
3after
;aa k
;
;9S
a
a
safa
also
a
iD
js !6
;2
fa 3
g6Wf;
1
;!;;
aa;af
activities
start
that
unique:
Not
a
7g.
g.ij
5
6
k after
2 k
;
a
a
<
S
a
9
a
sfa
also
a 8
D
jis!6
;2
fa g.
3
gWf! ;
1
activities
Dfinishes
start
that
iunique:
aNot
7g.
8
ij
58k after
;
a;af
finishes
2;ag.
set: k
9
a
;
S
< a
sfa
also
a8
D
jis!6
;2
fa 3
gW2f
!;
1 ;
;aa;af
activities
finishes
D start
that
iunique:
aNot
g.
7 ij
5 k after
fa k
a
;
<
S
9
a
sfa
also
a8
D
jis;2
!
fa
and 3
Wf
!
gand
;aa;af
activities
Dfinishes
iunique:
aNot
7g.
1 ij
5 start
that
k2after k
;
a
3
S
< a
safa
9also
3
D2
!
fa
siand
jfinish gWf
;!
;
1
a6a;af
activities
iunique:
Not
;g.
7 ;finishes
ij
5 start
that
k after
afinish
2 S
<
k
;
a a
sfaa
aD
82
!6
fa
sand
ijfinish
9;also
iNot
a 3
gW8f
!
activities
;finishes
D
unique:
7g. 5 kstart
that
;fS
after
a
;
<
;before
2aabefore
;a
g.k
9also
a
a
sfa a 8!
2
fa
sand6
ijfinish
D 3
gW2!
f ;
1
activities
finishes
;kstart
iunique:
Not
g.
7 5 that
after
;
fk<
;before
aa;a
a
;
374
S sfa
9also
k
a a
ijs
a
374 8 2!6
finish
and 3
gaWf
!
activities
D
iunique:
aNot
7g. 5finishes
;kjstart
that
;
1 ;
[Leave
after
2 f
;before
aa
j;a [Leave
S
<
[Leaveon
starts
k
9also sa
[Leave 8
onboard]
on !
board]
a 6start
[Leave
board]
on
[Leave
ijfinish
and 3
board]
ongWf!
activities
D
iunique:
fa
a Not
7g. 5;finishes
starts kjthat
2
;;f
a1a;a
[Leave
board]
on
[Leave
board]
on
[Leave
after board]
<
;beforeon
[Leave
board]
starts
k9 on
also
fa
a [Leave
iNot
a
board]
on 8
[Leav
bo
on
[!
sand6that
ij:finish
a
unique:
7g. 5 jk
3
!
f ;;<
gstart
activities
;finishes
D :after
2;before
a
a1a;starts
ak9also js
a8and
375 !
finish
:a D
aiunique
fa g.
7 gjg.
;6kstart
activi
5 f
finish
that
2
;;<
3afte
;befo
;a
a1a;astasfafa
aa afi8a5!
ai7j:g.
k9als ;fi6
Sélection d’activités : approche gloutonne
Considérer les activités par ordre croissant de fi et sélectionner
chaque activité compatible avec celles déjà prises
Implémentations : en supposant s et f ordonnés selon f
Rec-activity-selector(s, f , k, n) Iter-activity-selector(s, f )
1 m =k +1 1 n = s.length
2 while m ≤ n and s[m] < f [k] 2 A = {a1 }
3 m =m+1 3 k=1
4 if m ≤ n 4 for m = 2 to n
5 return {am } ∪ ... 5 if s[m] ≥ f [k]
6 ...Rec-activity-selector(s, f , m, n) 6 A = A ∪ {am }
7 else return ∅ 7 k=m
8 return A
Appel initial :
Rec-activity-selector(s, f , 0, s.length)
Complexité : Θ(n) (+Θ(n log n) pour le tri selon fi )

Sélection d’activités : analyse
La solution gloutonne est-elle correcte ?
1. Propriété des choix gloutons optimaux : Soit ax ∈ S tel que

fx ≤ fi pour tout ai ∈ S. Il existe une solution optimale OPT ∗ qui
contient ax .
Preuve :
I Soit une solution optimale OPT telle que ax ∈ / OPT
I Soit am l’activité qui se termine en premier dans OPT
I Construisons OPT ∗ = (OPT \ {am }) ∪ {ax }
I OPT ∗ est valide :
I Toute activité ai ∈ OPT \ {am } débute en un temps si ≥ fm
I Par définition de ax , fm ≥ fx et donc pour tout activité ai , si ≥ fx
I Toute activité ai est donc compatible avec ax
I OPT ∗ est donc optimale puisque |OPT ∗ | = |OPT |

Sélection d’activités : analyse
La solution gloutonne est-elle correcte ?
2. Propriété du sous-structure optimale : Soit ax ∈ S le choix
glouton et S 0 = {ai |si ≥ fx } les activités de S compatibles avec ax .
Soit OPT ∗ = {ax } ∪ OPT 0 . Si OPT 0 est une solution optimale pour
S 0 alors OPT ∗ est une solution optimale pour S.
Preuve :
I Soit OPT une solution optimale pour S
I Si OPT ∗ n’est pas une solution optimale pour S, alors
|OPT ∗ | < |OPT | et donc aussi |OPT 0 | < |OPT | − 1
I Soit am l’activité qui se termine en premier dans OPT et
S̄ = {ai |si ≥ fm }
I Par construction, OPT \ {am } est une solution pour S̄
I Par construction, S̄ ⊆ S 0 et OPT \ {am } est une solution valide pour
S 0 (pas nécessairement optimale)
I Ce qui veut dire qu’il existe une solution pour S 0 de taille |OPT | − 1,
ce qui contredit |OPT 0 | < |OPT | − 1 et OPT 0 optimal pour S 0 (par
hypothèse).

Problèmes similaires
D’autres problèmes similaires pour lesquels il existe un algorithme

glouton :
Allocations de resources :
I Etant donnée un ensemble d’activité S avec leurs temps de début et
de fin, trouver le nombre minimum de salles permettant de les réaliser
toutes
Planification de tâches :
I Soit un ensemble de tâches avec leur durée et l’instant à laquelle elles
doivent chacun être terminée (leur deadline)
I Sachant qu’on ne peut exécuter qu’une seule tâche simultanément,
trouver l’ordonnancement de ces tâches qui minimise le dépassement
maximal des deadlines associées aux tâches (latence).

Exemple 3 : problème du sac à dos
Rappel : problème (0/1) du sac à dos :

Soit un ensemble S de n objets de poids pi > 0 et de valeur vi > 0
Trouver x1 , x2 , . . . , xn ∈ {0, 1} tels que :
Pn
I

I
Solution par programmation dynamique : Θ(nW )
Peut-on le résoudre par une approche gloutonne ?

Programmation dynamique versus approche gloutonne
Rappel du transparent 359 :

I soit M(k, w ), 0 ≤ k ≤ n et 0 ≤ w ≤ W , le bénéfice maximum qu’on
peut obtenir avec les objets 1,. . . ,k de S et un sac à dos de charge
maximale w . On a :

 0 si i = 0
M(k, w ) = M(k − 1, w ) si pi > w

max{M(k − 1, w ), vk + M(k − 1, w − pk )} sinon
Approche gloutonne : consisterait à remplacer le max par le choix

qui nous semble le meilleur localement
Quels choix possibles ?
I Le moins lourd, le plus lourd ?
I Le moins couteux, le plus couteux ?
I Le meilleur rapport valeur/poids ?

Approche gloutonne
Idée d’algorithme :
I Ajouter à chaque itération l’objet de rapport pvii maximal qui rentre
dans le sac
I Implémentation très proche du problème de change : Θ(n log n)
Est-ce que ça fonctionne ? Non !
i vi pi vi /pi
1 1 1 1
2 6 2 3
3 18 5 3,6
4 22 6 3,7
5 28 7 4
W=11 :
I Solution greedy : {5, 2, 1} ⇒ valeur=35
I Solution DP : {4, 3} ⇒ valeur=40

Problème fractionnel du sac à dos (fractional knapsack)
Par rapport au problème 0/1, il est maintenant permis d’inclure des
fractions d’objets (≤ 1) :
Soit un ensemble S de n objets de poids pi > 0 et de valeur vi > 0
Trouver
P x1 , x2 , . . . , xn ∈ [0, 1] tels que :
n
I

I
Exemple : i vi pi vi /pi
1 1 1 1
2 6 2 3
3 18 5 3,6
4 22 6 3,7
5 28 7 4
W=11 :
Solution optimale 0/1 : x1 = 0, x2 = 0, x3 = 1, x4 = 1, x5 = 0 ⇒
valeur=40
Solution optimale fractionnelle : x1 = 0, x2 = 0, x3 = 0, x4 = 2/3, x5 = 1
⇒ valeur=42,66
Algorithme glouton
Pour la version fractionnelle, l’algorithme glouton est optimal

Implémentation :
FracKnapSack(p, v , n, W )
1 // Assume the objects are sorted according to v [i]/p[i]
2 Let x[1 . . n] a new table
3 w =0
4 for i = 1 to n
5 d = min(p[i], W − w )
6 w = w +d
7 x[i] = d/p[i]
8 return x
Complexité : Θ(n) (+ Θ(n log n) pour le tri)

Correction
Théorème : Le problème fractionnel du sac à dos possède la propriété des
choix gloutons optimaux
Preuve :
Soit deux objets i et j tels que
vi vj
>
pi pj
Etant donné un choix (x1 , x2 , . . . , xn ), on le transforme en
(x10 , x20 , . . . , xn0 ) tel que :
I ∀k ∈ [1, n] \ {i, j} : xk0 = xk ,
I xi0 = xi + ∆
pi , et
I xj = xj + p∆j ,
0
où ∆ = min(pi (1 − xi ), pj xj ).
Cette transformation ne modifie pas le poids total, mais améliore le
bénéfice.
On en déduit qu’il est toujours avantageux de prendre la fraction
maximale de l’objet i possédant le plus grand rapport pvii .
Algorithme glouton : résumé
Très efficaces quand ils fonctionnent. Simples et faciles à

implémenter
Ne fonctionne pas toujours. Leur correction peut être assez difficile à
prouver
Applications :
Arbre de couverture minimal (voir partie 7)
Plus court chemin dans un graphe (algorithme de Dijkstra)
Allocation de resources
Codage de Huffman
...

Approche gloutonne versus programmation dynamique
Tous deux nécessitent la propriété de sous-structure optimale
Les algorithmes gloutons nécessitent que la propriété de choix

gloutons optimaux soit satisfaite
I On n’a pas besoin de solutionner plus d’un sous-problème
I Le choix glouton est fait avant de résoudre le sous-problème
I Il n’y a pas besoin de stocker les résultats intermédiares
La programmation dynamique marche sans la propriété des choix

gloutons optimaux
I On doit solutionner plusieurs sous-problèmes et choisir
dynamiquement l’un deux pour obtenir la solution globale
I La solution doit être assemblée “bottom-up”
I Les sous-solutions aux sous-problèmes sont réutilisées et doivent donc
être stockées

Exemple 4 : codage de Huffman
Soit une séquence S très longue définie sur base de 6 caractères : a,

b, c, d, e et f
I Par exemple, n = |S| = 109
Quelle est la manière la plus efficace de stocker cette séquence ?
Première approche : encoder chaque symbole par un mot binaire de

longueur fixe :
Symbole a b c d e f
Codage 000 001 010 011 100 101
I 6 symboles nécessitent 3 bits par symboles
I 3 × 109 /8 = 3.75 × 108 bytes (un peu moins de 400Mb)

Idée
Codage avec des mots de longueur fixe :
Symbole a b c d e f
Codage 000 001 010 011 100 101
Observation : l’encodage de e et f est redondant :
I Le second bit ne nous aide pas à distinguer e de f
I En d’autres termes, si le premier bit est 1, le second ne nous donne
pas d’information et peut être supprimé
Suggère de considérer un codage avec des mots binaires de
longueurs variables
Symbole a b c d e f
Codage 000 001 010 011 10 11
Encodage et décodage sont bien définis et non ambigüs
Permet de gagner ne + nf bits, où ne et nf sont les nombres de e et
de f dans la séquence

Définition du problème
Soit un ensemble de symboles C et f (c) la fréquence du symbole
c ∈ C.
Trouver un code E : C → {0, 1}∗ tel que
I E est un code sans préfixe
I Aucun mot de code E (c1 ) n’est le préfixe d’un autre mot de code
E (c2 )
I La longueur moyenne des mots de code est minimale
X
B(S) = f (c)|E (c)|
c∈C
(nB(S) est la longueur de l’encodage de S)

Exemple :
c a b c d e f
f(c) 45% 13% 12% 16% 9% 5% B(S)
Code 1 000 001 010 011 100 101 3.00
Code 2 000 001 010 011 10 11 2.86
Code 3 0 101 100 111 1101 1100 2.24

Chapter 16 Greedy Algorithms
Code sans préfixe
430 Chapter 16 Greedy Algorithms
100 100
0 1 0 1
86 100 14 a:45 55
100
0 1 0 0 1 00 11
58 28 86 14 14 25
a:45 5530
0 1 00 1 1 0 1 0 0 1 0 0 11
a:45 b:13 58
c:12 d:16 28
e:9 f:5 14 c:12 25
b:13 14 d:1630
0 1 0 1 0 1 0 01 1 0 1
a:45 b:13 c:12 d:16 e:9 f:5 c:12 b:13 14 d:16
f:5 e:9
0 1
(a) (b) f:5 e:9
Un code sans préfixe peut toujours se représenter sous la forme
d’une arbre binaire(a) (b)
Figure 16.4 Trees corresponding
I Chaque feuille esttoassociée
the codingàschemes in Figure 16.3. Each leaf is labeled with
un symbole
a character
I andLe its frequency
chemin deofcorresponding
laoccurrence.
racine àtoEach
une internal
feuille node
est isleinlabeled with
code 16.3. the sum of the fre-
du symbole
Figure 16.4 Trees the coding schemes Figure Each leaf is labeled with
of the leaves in its subtree. (a) The tree corresponding to the fixed-length code a = 000, . . . ,
quencies I
a La
character and
fréquence its frequency
d’un of
nœud occurrence.
est la Each internal
fréquence node
du is labeled
préfixe with the sum of the fre-
f = 101. (b)quencies
The treeofcorresponding
the leaves in its to the optimal
subtree. (a) Theprefix code a = 0, bto=the
tree corresponding 101, . . . , f = 1100.
fixed-length code a = 000, . . . ,
Un code
f = 101.optimal
(b) The treeest toujours
corresponding représenté
to the optimal prefix par
code aun
= 0,arbre
b = 101,binaire entier
. . . , f = 1100.
acter,(Pourquoi
and repeat the
?) decoding process on the remainder of the encoded file. In our
example, acter,
the string
and repeat parsesprocess
the decoding
001011101 uniquely
on as
the0remainder of the which
! 0 ! 101 ! 1101, encodeddecodes
file. In our
to aabe.example, the string 001011101 parses uniquely as 0 ! 0 ! 101 ! 1101, which decodes
to aabe.
Algorithme glouton
On peut montrer que le codage optimal peut être obtenu par un
algorithme glouton
On construit l’arbre de bas en haut en partant des feuilles
A chaque étape, on fait le choix “glouton” de fusionner les deux
nœuds les moins fréquents (symboles ou préfixes)
Idée de la preuve (pour information) :

Choix gloutons optimaux :
I Il existe un code sans préfixe optimal où les deux symboles les moins
fréquents sont frères et à la profondeur maximale
I Par l’absurde : si un tel code n’existait pas, on pourrait l’obtenir en
échangeant la position des deux symboles les moins fréquents avec les
feuilles les plus profondes sans augmenter B(S)
Sous-structure optimale :
I Si l’arbre qui a pour feuille le nouveau nœud issu de la fusion
gloutonne est optimal, l’arbre complet est optimal
I Plus difficile à montrer
Algorithme
432
glouton : exemple
Chapter 16 Greedy Algorithms
(a) f:5 e:9 c:12 b:13 d:16 a:45 (b) c:12 b:13 14 d:16 a:45
0 1
f:5 e:9
(c) 14 d:16 25 a:45 (d) 25 30 a:45

0 1 0 1 0 1 0 1
f:5 e:9 c:12 b:13 c:12 b:13 14 d:16
0 1
f:5 e:9
(e) a:45 55 (f) 100

0 1 0 1
25 30 a:45 55
0 1 0 1 0 1
c:12 b:13 14 d:16 25 30
0 1 0 1 0 1
f:5 e:9 c:12 b:13 14 d:16
0 1
f:5 e:9
Figure 16.5 The steps of Huffman’s algorithm for the frequencies given in Figure 16.3. Each part 393
Algorithme glouton : implémentation
Huffman(C )
1 n = |C |
2 Q =”create a min-priority queue from C ”
3 for i = 1 to n − 1
4 Allocate a new node z
5 z.left = Extract-Min(Q)
6 z.right = Extract-Min(Q)
7 z.freq = z.left.freq + z.right.freq
8 Insert(Q, z)
9 return Extract-min(Q)
Implémentation avec une file à priorité

Complexité : O(n log n) si Q est implémentée avec un tas (min)
I Ligne 2 : O(n) si on utilise Build-min-heap
I Ligne 8 : O(log n) (répétée n − 1 fois)

Partie 7
Graphes
Graphes 395
Plan
1. Définitions
2. Représentation des graphes
3. Parcours de graphes
4. Plus courts chemins
5. Arbre couvrant
Graphes 396
Graphes
Un graphe (dirigé) est un couple (V , E ) où :

I V est un ensemble de nœuds (nodes), ou sommets (vertices) et
I E ⊆ V × V est un ensemble d’arcs, ou arêtes (edges).
Un graphe non dirigé est caractérisé par une relation symmétrique
entre les sommets
I Une arête est un ensemble e = {u, v } de deux sommets
I On la notera tout de même (u, v ) (équivalent à (v , u)).
Applications : modélisation de :
I Réseaux sociaux
I Réseaux informatiques
I World Wide Web
I Cartes routières
I ...
Graphes 397
Terminologie : graphe non dirigé
1 2 5
1 2 2 1 5 3
3 2 4
3
4 2 5 3
5 4 5 4 1 2
(a) (b)
V = {1, 2, 3, 4, 5}, E = {(1, 2), (1, 5), (2, 5), (2, 3), (3, 4), (4, 5)}
Figure 22.1 Two representations of an undirected g
Deux nœuds sont adjacents s’ilsand 7 edges.
sont (b) une
liés par An adjacency-list
même arête representation o
of G. aux nœuds v et v
Une arête (v1 , v2 ) est dite incidente 1 2
Le degré d’un nœud est égal au nombre de ses arêtes incidentes
Le degrée d’un graphe est le nombre maximal d’arêtes incidentes à
tout sommet. 1 2 4
Un graphe est connexe s’il existe un chemin de tout sommet à tout 2 5
autre. 1 2 3 3 6 5
Une composante connexe d’un graphe non orienté est un 4 2
sous-graphe connexe maximal de ce graphe 5 4
4 5 6 6 6
Graphes 398
1 2 4
Terminologie : graphe dirigé 2 5
1 2 3 3 6 5
4 2
5 4
4 5 6 6 6
(a) (b)
V = {1, 2, 3, 4, 5, 6}, E = {(1, 2), (1, 4), (2, 5), (3, 5), (3, 6), (4, 2), (5, 4), (6, 6)}
Figure 22.2 Two representations of a directed graph.
edges. (b) An adjacency-list representation of G. (c) Th
Une arête (v1 , v2 ) possède l’origine v1 et la destination v2 . Cette
arête est sortante pour v1 et shortest-paths
entrante pouralgorithms
v2 presented in Chapt
Le degré entrant (in-degree) are et lerepresented by adjacency
degré sortant matrices.
(out-degree) d’un
nœud v sont respectivement égaux adjacency-list
The aux representation
nombres d’arêtes of a gr
entrantes
et d’arêtes sortantes de v ray Adj of jV j lists, one for each vertex in V
AdjŒu!
Un graphe est acyclique s’il n’y a aucun contains all c’est-à-dire
cycle, the vertices s’il
" such
n’estthat th
pas possible de suivre les arêtes du graphes à partir d’un sommet x to u
AdjŒu! consists of all the vertices adjacent
et de revenir à ce même sommet pointers
x to these vertices.) Since the adjacency
in pseudocode we treat the array Adj as an at
Graphes 399
Type de graphes
Un graphe est simple s’il ne possède pas de boucle composée d’une

seule arête, c’est-à-dire tel que :
∀v ∈ V : (v , v ) ∈
/E
Un arbre est un graphe acyclique connexe

Un multigraphe est une généralisation des graphes pour laquelle il
est permis de définir plus d’une arête liant un sommet à un autre
Un graphe est pondéré si les arêtes sont annotées par des poids
I Exemple : réseau entre villes avec comme poids la distance entre les
villes, réseau internet avec comme poids la bande passante entre
routeurs, etc.
Graphes 400
Représentation I : listes d’adjacences
Un objet G de type graphe est composé :

d’une liste de nœuds G .V = {1, 2, . . . , |V |}
d’un tableau G .Adj de |V | listes tel que :
I Chaque sommet u ∈ G .V est représenté par une élément du tableau
G .Adj
I G .Adj[u] est la liste d’adjacence de u, c’est-à-dire la liste des
sommets v tels que (u, v ) ∈ E
Permet de représenter des graphes dirigés ou non

Si le graphe est dirigé (resp. non dirigé), la somme des longueurs des
listes de G .Adj est |E | (resp. 2|E |).
Permet de représenter un graphe pondéré en associant un poids à chaque

élément de liste
Graphes 401
1 2 5 1
1 2 2 1 5 3 4 2
Exemple 3 2 4 3
590 Chapter 22 3 Elementary Graph
4 Algorithms
2 5 3 4
5 4 5 4 1 2 5
Graphe non dirigé 1 2 3
(a) 1 2 5 (b) 1 0 1 0
1 2 2 1 5 3 4 2 1 0 1
3 2 4 3 0 1 0
Figure322.1 Two representations of an undirected graph. (a) An undirected gra
4 2 5 3 4 0 1 1
and 7 edges. (b) An adjacency-list representation of G. (c) The adjacency-m
5 4 5 4 1 2 5 1 1 0
of G.
(a) (b) (c
Graphe dirigé 1
Figure 22.1 Two representations of1an undirected
2 graph.4(a) An undirected graph G1with0
and 7 edges. (b) An adjacency-list 2representation
5 of G. (c) The adjacency-matrix2repr0
of G.
1 2 3 3 6 5 3 0
4 2 4 0
1 2 3 4
5 4 5 0
1 2 4 1 0 1 0 1
4 5 6 2 6 5 6 2 0 0 60 00
1 2 3 3 6
(a) (b)5 3 0 0 0 0
4 2 4 0 1 0 0
5 4 5 0 0 0 1
Graphes
4 5Figure 22.2
6 6 6 6 0 graph
Two representations of a directed graph. (a) A directed 0 402
0G 0
Complexités
Complexité en espace : O(|V | + |E |)

I optimal
Accéder à un sommet : O(1)
I optimal
Parcourir tous les sommets : Θ(|V |)
I optimal
Parcourir toutes les arêtes : Θ(|V | + |E |)
I ok (mais pas optimal)
Vérifier l’existence d’une arête (u, v ) ∈ E : O(|V |)
I ou encore O(min(degree(u), degree(v )))
I mauvais
(Exercice : insertion, suppression de nœuds et d’arêtes ?)
Graphes 403
Réprésentation II : matrice d’adjacence
Les nœuds sont les entiers de 1 à |V |, G .V = {1, 2, . . . , |V |}

G est décrit par une matrice G .A de dimension |V | × |V |
G .A = (aij ) tel que

1 si (i, j) ∈ E
aij =
0 sinon
Permet de représenter des graphes dirigés ou non

I G .A est symmétrique si le graphe est non dirigé
Graphe pondéré : aij est le poids de l’arête (i, j) si elle existe, NIL
(ou 0, ou +∞) sinon
Graphes 404
1 2 3 4 5
Exemple
1 2
590
Graph Algorithms
5 Chapter 22 1 2 15 0 0 1
Elementary Graph0 Algorithms
1
2 1 1 5 23 4 2 12 1 05 1 1 3 1 4
Graphe non dirigé
3 2 4 3 23
14 0 1 0
0
3
4 2 5 3 4 21
02 135 14 0 53 1
4
52 45 5 1 42 5 1 1 40
5 211 101 005 1 12 0
1 2 2 1 5 3 4
1 5 3 (a)
(b) 4 2 10 1(b) (c)14 1
3 2
2 4 3 3 0 1 0 1 0
4 2 5 3
2 5 3 Figure 22.1 Two representations
4 0 of1an undirected
1 0 1 graph. (a) An undirected
wo representations of an undirected graph. (a) An undirected graph G with 5 vertices 2
5 4 5 4 1
4 1 2 and 7 edges. (b) An adjacency-list
5 1 1representation
0 1 0 of G. (c) The adjacenc
b) An adjacency-list representation of G. (c) The adjacency-matrix representation
of G.
(a) (b)
(b) (c)
Graphe dirigé
1 2 of
Figure 22.1 Two representations 3 an4 undirected
5 6 graph. (a) An und
1 2 4 1
entations of an1undirected 4 (a)
2 graph.
and An undirected
7 edges. graph
1 0G with
1 0 5representation
(b) An adjacency-list vertices
1 0 0 of G. (c) The 2a
2 5
acency-list representation
2 5 of G. (c) The adjacency-matrix
of G. 2 0 0representation
0 0 1 0
1 2 3 3 6 5 3
3 6 5 3 40 0 02 0 1 1 4
4 2 4 50 1 04 0 0 0 5
5 4 4 5 6 5 0 0 0
1 62 13 46 52 61 0 0 6
4
1 62 6 4 1 6 1
0 0 00 01 00 0 0 1
(a) 2 (b) 5
Graphes 405
Complexités
Complexité en espace : O(|V |2 )

I potentiellement très mauvais
Accéder à un sommet : O(1)
I optimal
Parcourir tous les sommets : Θ(|V |)
I optimal
Parcourir toutes les arêtes : Θ(|V |2 )
I potentiellement très mauvais
Vérifier l’existence d’une arête (u, v ) ∈ E : O(1)
I optimal
(Exercice : insertion, suppression de nœuds et d’arêtes ?)
Graphes 406
Représentations
Listes d’adjacence :
I Complexité en espace optimal
I Pas appropriée pour des graphes denses1 et des algorithmes qui ont
besoin d’accéder aux arêtes
I Préférable pour des graphes creux2 ou de degré faible
Matrice d’adjacence :
I Complexité en espace très mauvaise pour des graphes creux
I Appropriée pour des algorithmes qui désirent accéder aléatoirement
aux arêtes
I Préférable pour des graphes denses
1
|E | ≈ |V |2
2
|E | |V |2
Graphes 407
Plan
1. Définitions
5. Arbre couvrant
Graphes 408
Parcours de graphes
Objectif : parcourir tous les sommets d’un graphe qui sont

accessibles à partir d’un sommet v donné
Un sommet v 0 est accessible à partir de v si :
I soit v 0 = v ,
I soit v 0 est adjacent à v ,
I soit v 0 est adjacent à un sommet v 00 qui est accessible à partir de v
Différents types de parcours :

I En profondeur d’abord (depth-first)
I En largeur d’abord (breadth-first)
Graphes 409
Parcours en largeur d’abord (breadth-first search)
Un des algorithmes les plus simples pour parcourir un graphe

A la base de plusieurs algorithmes de graphe importants
Entrées : un graphe G = (V , E ) et un sommet s ∈ V

I Parcourt le graphe en visitant tous les sommets qui sont accessibles à
partir de s
I Parcourt les sommets par ordre croissant de leur distance (en nombre
minimum d’arêtes) par rapport à s
I on visite s
I tous les voisins de s
I tous les voisins des voisins de s
I etc.
I Fonctionne aussi bien pour des graphes dirigés que non dirigés
Graphes 410
Exemple directed graph [undirected example in book] .
0 3
s 1 f
c
1
a g 2
e 2 i
3
b h
3 3
Un parcours en largeur à partir de s : s-a-c-e-g -b-h-i-f
Can show that Q consists of vertices with d valu
Pour l’implémentation :
On doitiretenir
i les
i sommets C 1 deimanière
: : : idéjài visités C 1 à:éviter
: : ideC 1
boucler infiniment
Only
On doit!retenir 1 or 2 values.
les sommets visités dont on n’a pas encore visité les
voisins
! If 2, differ by 1 and all smallest are first.
Graphes 411
Parcours en largeur d’abord : implémentation
BFS(G , s)
v .d est la distance de v à s
1 for each vertex u ∈ G .V \ {s} I si un sommet v a été visité,
2 u.d = ∞
v .d est fini
3 s.d = 0 I on peut remplacer d par un
4 Q =”create empty Queue”
drapeau binaire
5 Enqueue(Q, s)
6 while not Queue-Empty(Q)
7 u = Dequeue(Q) Q est une file (LIFO) qui
8 for each v ∈ G .Adj[u] contient les sommets visités
9 if v .d = ∞ mais dont les voisins n’ont pas
10 v .d = u.d + 1
encore été visités
11 Enqueue(Q, v )
Graphes 412
Parcours en largeur d’abord : complexité
BFS(G , s)
1 for each vertex u ∈ G .V \ {s} Chaque sommet est enfilé
2 u.d = ∞
au plus une fois (v .d
3 s.d = 0
4 Q=∅ infini → v .d fini)
5 Enqueue(Q, s) Boucle while exécutée
6 while Q 6= ∅ O(|V |) fois
7 u = Dequeue(Q)
Boucle interne : O(|E |)
8 for each v ∈ G .Adj[u]
9 if v .d = ∞ au total
10 v .d = u.d + 1 Au total : O(|V | + |E |)
11 Enqueue(Q, v )
Graphes 413
Parcours en largeur d’abord
Correction :
I L’algorithme fait bien un parcours du graphe en largeur et v .d
contient bien la distance minimale de s à v
I Ok intuitivement mais pas évident à montrer formellement. On le fera
plus loin pour l’algorithme de Dijkstra (calcul du plus court chemin)
Applications :
I Calcul des plus courtes distances d’un sommet à tous les autres
I Recherche du plus court chemin entre deux sommets
I Calcul du diamètre d’un arbre
I Tester si un graphe est biparti
I ...
Graphes 414
DFS-V ISIT .!/
Parcours enu:color
profondeur
D BLACK d’abord
Parcourstime
du D time Cen
graphe 1 profondeur :
I On u:f time
suitDimmédiatement les arêtes//incidentes
finish u au dernier sommet visité
I Au lieu de les mettre en attente dans une file
I On revient en arrière (backtrack) quand le sommet visité n’a plus de
Example
sommets adjacents
[Go through non visités
this example, adding in the d and f values as they’re computed.
colors as they change. Don’t put in the edge types yet.]
Exemple :
d f
T C
1 A12 8 B11 13C16
T T C
B F C T
2D 7 9 E10
T
T C
3F 4 5 G6 14H15
C C
Parcours en profondeur à partir de A : A-D-F -G -B-E (C et H pas

accessibles)
Graphes 415
Parcours en profondeur : implémentation avec une pile
On remplace la file Q
par une pile S
L’attribut visited
DFS(G , s)
marque les sommets
1 for each vertex u ∈ G .V
2 u.visited = False visités
3 S =”create empty stack”
4 Push(S, s) Chaque sommet est
5 while not Stack-empty(S) empilé au plus une fois
6 u = Pop(S)
Boucle while
7 if u.visited == False
8 u.visited = True executées O(|V |) fois
9 for each v ∈ G .Adj[u] Boucle interne :
10 if v .visited == False O(|E |) au total
11 Push(S, v )
Complexité :
O(|V | + |E |)
Graphes 416
Parcours en profondeur : implémentation récursive
DFS(G , s) Remplace la pile par la

1 for each vertex u ∈ G .V récursion
2 u.visited = False
3 DFS-rec(G , s)
DFS-REC appelée au plus
|V | fois
DFS-Rec(G , s) Chaque arête est considérée
1 s.visited = True au plus une fois dans la
2 for each v ∈ G .Adj[s]
boucle for
3 if v .visited == False
4 DFS-Rec(G , v ) Complexité : O(|V | + |E |)
Graphes 417
Parcourir tous les sommets d’un graphe
BFS et DFS ne visitent que les nœuds accessibles à partir de la

source s
I Graphe non dirigé : seule la composante connexe contenant s est
visitée
I Graphe dirigé : certains sommets peuvent ne pas être accessibles de s
en suivant le sens des arêtes
Pour parcourir tous les sommets d’un graphe :
1. On choisit un sommet arbitraire v
2. On visite tous les sommets accessibles depuis v (en profondeur ou en
largeur)
3. S’il reste certains sommets non visités, on en choisit un et on
retourne en (2)
Graphes 418
Parcours en profondeur de tous les sommets
DFS-all(G )
DFS-Rec(G , s)
1 s.visited = True
2 u.visited = False
3 if v .visited == False
4 if u.visited == False
4 DFS-Rec(G , v )
5 DFS-Rec(G , u)
Complexité : Θ(|V | + |E |)
I DFS-Rec est appelé sur chaque sommet une et une seule fois
Θ(|V |)
I La boucle for de DFS-Rec parcourt chaque liste d’adjacence une et

une seule fois X
Θ( outdegree(u)) = Θ(|E |)
u∈G .V
Graphes 419
v∈V
Sous-graphe de liaison
Tdfs (n, m) = Θ(n + m).
count an undirected edge as two edges, one in each direction. We then get
(v) = 2m for undirected graphs, but since 2m ∈ Θ(m), this does not really
Un parcours en profondeur de tous les sommets d’un graphe construit un
rence.
ensemble d’arbres (une forêt), appelé sous-graphe de liaison, où :
S Forestsles sommets sont les sommets du graphe,
un sommet w est le fils d’un sommet v dans la forêt si
CS2
DFS starting at some vertex Algorithms
v explores and Data
the graph Structures
by building up aNote
tree 10
that CS2Bh 31 January 20
vertices that are reachable from v and all edges that are used to reach
DFS-rec(G , w ) est appelé depuis DFS-rec(G , v )
es. We call this tree a DFS tree. A complete DFS exploring the full graph
Suppose,
y the part reachable from a given vertexfor example,
v) builds up athat we explore
collection the graph in Figure 10.3 by a DFS s
of trees,
lled a DFS forest. vertex 0 that visits the vertices in the following order: 0, 2, 1, 5, 4, 3, 6. The corre
Exemple : DFS forest is shown in Figure 10.4.
0 1 0 3
2 3 2 4 6
4 5 6 1 5
Figure 10.3. Figure 10.4.

(Exercice : modifiez DFS-All et DFS-Rec pour construire la forêt)
Note2that, just like the order in which the vertices are visited during a DF
Graphes forest is not unique. Figure 10.5 shows another DFS forest for the graph in Fig
420
Application : tri topologique
Tri topologique :
I Etant donné un graphe acyclique dirigé (DAG), trouver un ordre des
sommets tel qu’il n’y ait pas d’arête d’un nœud vers un des nœuds
qui le précède dans l’ordre
I On peut montrer que c’est possible si (et seulement si) le graphe est
acyclique
Exemples d’applications :
I Trouver un ordre pour suivre un ensemble de cours qui tienne compte
des prérequis de chaque cours
I Pour suivre SDA, il faut avoir suivi Introduction à la programmation
I Résoudre les dépendances pour l’installation de logiciels
I Trouver un ordre d’installation de manière à ce que chaque logiciel
soit installé après tous ceux dont il dépend
Graphes 421
Illustration
22.4 Topological sort
Graphe
22.4 Topological sort 613
11/16 undershorts socks 17/18

11/16 undershorts socks 17/18 watch 9/10
12/15 pants watch
shoes9/1013/14
12/15 pants shoes 13/14
shirt 1/8
shirt 1/8
(a) 6/7 belt
(a) 6/7 belt
tie 2/5
tie 2/5
jacket 3/4 jacket 3/4
Une tri topologique
(b) socks undershorts pants shoes watch shirt belt tie jacket
(b) socks undershorts pants shoes watch shirt belt tie
17/18 11/16 12/15 13/14 9/10 1/8 6/7 2/5 3/4
17/18 11/16 12/15 13/14 9/10 1/8 6/7 2/5
Figure 22.7 (a) Professor Bumstead topologically sorts his clothing when getting dressed. Each
directed edge
Figure means(a)
.u; !/22.7 thatProfessor
garment uBumstead
must be puttopologically
on before garment hisThe
sorts !. discovery
clothing andgetting dresse
when
Graphes 422
Marquage des sommets pour le parcours en profondeur
Dans le cadre d’un parcours en profondeur de tous les sommets,

DFS-rec est appelé une et une seule fois sur chaque sommet
Lors de l’exécution de DFS-All, on dira qu’un sommet v est fini si
l’appel DFS-rec(G , v ) est terminé
A un moment donné, les sommets peuvent être dans les trois états
suivants :
I pas encore visité (on dira que v est blanc)
I visité mais pas encore fini (v est gris)
I fini (v est noir)
Graphes 423
Marquage des sommets pour le parcours en profondeur
DFS-all(G ) DFS-Rec(G , s)
1 for each vertex u ∈ G .V 1 s.color = Gray
2 u.color = White 2 for each v ∈ G .Adj[s]
3 for each vertex u ∈ G .V 3 if s.color == White
4 if u.color == White 4 DFS-Rec(G , v )
5 DFS-Rec(G , u) 5 s.color = Black
Lemme. Soit s un sommet de G . Considérons le moment de

l’exécution de DFS-All(G ) où DFS-Rec(G , s) est appelé. Pour
tout sommet v , on a :
1. Si v est blanc et accessible depuis s, alors v sera noir avant s
2. Si v est gris, alors s est accessible depuis v
Graphes 424
Trouver un tri topologique par DFS
Soit un graphe G = (V , E ) et l’ordre suivant défini sur V :
s ≺ v ⇔ v devient noir avant s
Si G est un DAG, alors ≺ définit un ordre topologique sur G
Preuve :
I Soit (s, v ) ∈ E . On doit montrer que s ≺ v .
I Considérons le moment où DFS-rec(G , s) est appelé :
I Si v est déjà noir, alors s ≺ v par définition de ≺
I Si v est blanc, alors v sera noir avant s par le lemme précédent. Donc
s≺v
I Si v est gris, s est accessible depuis v et donc il y a un cycle (puisque
(s, v ) ∈ E ). Ce qui ne peut pas arriver vu que G est un DAG
Graphes 425
Tri topologique : implémentation
Top-Sort-Rec(G , s, L)
Top-Sort(G )
1 s.color = Gray
2 u.color = White
3 if s.color = = White
3 L =”create empty linked list”
4 Top-Sort-Rec(G , v , L)
5 elseif s.color = = Grey
5 if u.color = = White
6 Error ”G has a cycle”
6 Top-Sort-Rec(G , u, L)
7 s.color = Black
7 return L
8 Insert-First(L, s)
Graphes 426
Illustration
22.4 Topological sort
Graphe
22.4 Topological sort 613
11/16 undershorts socks 17/18

11/16 undershorts socks 17/18 watch 9/10
12/15 pants watch
shoes9/1013/14
12/15 pants shoes 13/14
shirt 1/8
shirt 1/8
(a) 6/7 belt
(a) 6/7 belt
tie 2/5
tie 2/5
jacket 3/4 jacket 3/4
Une tri topologique
(b) socks undershorts pants shoes watch shirt belt tie jacket
(b) socks undershorts pants shoes watch shirt belt tie
17/18 11/16 12/15 13/14 9/10 1/8 6/7 2/5 3/4
17/18 11/16 12/15 13/14 9/10 1/8 6/7 2/5
Figure 22.7 (a) Professor Bumstead topologically sorts his clothing when getting dressed. Each
directed edge
Figure means(a)
.u; !/22.7 thatProfessor
garment uBumstead
must be puttopologically
on before garment hisThe
sorts !. discovery
clothing andgetting dresse
when
Graphes 427
Une autre solution
Approche gloutonne :
I Rechercher un sommet qui n’a pas d’arête entrante
I C’est toujours possible dans un graphe acyclique
I Ajouter ce sommet à un tri topologique du graphe dont on a retiré ce
sommet et toutes ses arêtes
I Ce graphe reste acyclique
Complexité identique à l’approche DFS : Θ(|E | + |V |)
Graphes 428
Plan
1. Définitions
5. Arbre couvrant
Graphes 429
Définitions
Soit un graphe dirigé G = (V , E ) et une fonction de poids
w : E → IR
Un chemin (du sommet v1 au sommet vk ) est une séquence de
nœuds v1 , v2 , . . . , vk telle que ∀i = 1, . . . , k − 1, (vi , vi+1 ) ∈ E .
Le poids (ou coût) d’un chemin p est la somme du poids des arêtes
qui le composent :
w (p) = w (v1 ,648
v2 ) + w (v2 , vChapter
3 ) + . 24
. . +Single-Source
w (vk−1 , vShortest
k) Paths
Exemple
t x t
6 6
3 9 3
3 3
4 4
s 0 2 1 2 7 s 0 2 1
3 3
5 5
5 11 5
6 6
y z y
(a) (b)
w (s → y → t → x → z) = 5 + 1 + 6 + 2 = 14
Graphes Figure 24.2 (a) A weighted, directed graph
430wi
Plus courts chemins : définition
Un plus court chemin entre deux sommets u et v est un chemin p
de u à v de poids w (p) le plus faible possible
δ(u, v ) est le poids d’un plus court chemin de u à v :
δ(u, v ) = min{w (p)|p est un chemin de u à v }
(S’il n’y a pas de chemin entre u et v , δ(u, v ) = ∞ par définition)

r 24 Single-Source
Exemples Shortest
: Paths
x t x t x
6 6
9 3 9 3 9
3 3
4 4
2 7 s 0 2 1 2 7 s 0 2 1 2 7
3 3
5 5
11 5 11 5 11
6 6
z y z y z
(b) (c)
Graphes 431
Plus courts chemins : exemple d’application
Graphes 432
Propriété de !sous-structure optimale
If we have a negative-weight cycle, we can just keep
w.s; !/ D !1 for all ! on the cycle.
! But OK if the negative-weight cycle is not reachable fr
Lemme : Tout
! sous-chemin
Some d’un work
algorithms chemin le plus
only courtare
if there estno
unnegative-we
chemin
le plus court entre
We’llses
beextrémités
clear when they’re allowed and not allowed.
Preuve : Par l’absurde
I Soit unOptimal
plus courtsubstructure
chemin puv entre u et v et soit un sous-chemin pxy
de ce chemin défini par ses extrémités x et y
I S’il existe un chemin plus court que pxy entre x et y , on pourrait
Lemma
remplacer pxy par ce chemin dans le chemin entre u et v et obtenir
Any
ainsi un subpath
chemin of a shortest
plus court pathuisetavshortest path.
que puv entre
Proof Cut-and-paste.
pux pxy pyv
u x y v
Suppose this path p is a shortest path from u to !.

Graphes Then ı.u; !/ D w.p/ D w.pux / C w.pxy / C w.py! /.433
Poids négatifs
Les poids peuvent être négatifs
Ok la plupart du temps mais non permis par certains algorithmes
(Dijkstra)
Problème en cas de cycle de poids négatif (cycle absorbant) :
I En restant dans le cycle négatif, on peut diminuer arbitrairement le
poids du chemin
I646 Chapter 24 Single-Source Shortest Paths
Par définition, on fixera δ(u, v ) = −∞ s’il y a un chemin de u à v qui
passe par un cycle négatif
a b
–4
3 –1
h i
3 4 2
∞ ∞
s c 6 d g
5 8
0 5 11 –∞ –8 3
–3
∞
2 e 3 f 7
j
–∞ –∞
–6
δ(s,
Figuree) = δ(s,
24.1 f ) edge
Negative = δ(s, g ) in=a −∞
weights directed graph. The shortest-path weigh
Graphes appears within each vertex. Because vertices e and f form a negative-weight cycle
434 r
Cycles
Un chemin le plus court ne peut pas contenir de cycles

Cycles de poids négatifs : on les a déjà exclus par définition
Cycles de poids positifs : on peut obtenir un chemin plus court en
les supprimant
Cycles de poids nuls : il n’y a pas de raison de les utiliser et donc, on
ne le fera pas
Graphes 435
Plus courts chemins : variantes de problèmes
Différentes variantes du problème :

Origine unique : trouver tous les plus courts chemins d’un sommet à
tous les autres
I Algorithmes de Dijkstra et Bellman-Ford
Destination unique : trouver tous les plus courts chemins de tous les
sommets vers un sommet donné
I Essentiellement le même problème que l’origine unique
Paire unique : trouver un plus court chemin entre deux sommets
donnés.
I Pas de meilleure solution que de résoudre le problème “origine
unique”.
Toutes les paires : trouver tous les plus courts chemin de u à v pour
toutes les paires de sommets (u, v ) ∈ V × V .
I Algorithme de Floyd-Warshall
Graphes 436
Recherche du plus court chemin, origine unique
Entrées : un graphe dirigé pondéré et un sommet s (l’origine)

Sorties : deux attributs pour chaque sommet :
v .d = δ(s, v ), la plus courte distance de s vers chaque nœud
I
v .π = le prédécesseur de chaque sommet v dans un plus court

I
Chapter 24 chemin
Single-Source
de s à v Shortest Paths
(formant l’arbre des plus courts chemins partant de s)
t x t x t
6 6
3 9 3 9 3
3 3
4 4
1 2 7 s 0 2 1 2 7 s 0 2 1
3 3
5 5
5 11 5 11 5
6 6
y z y z y
(a) (b) de la valeur de δ(0, v ))
(Chaque nœud v est marqué (c)
Graphes 437
Approche force brute
Calculer le poids de tous les chemins entre deux nœuds et renvoyer

le plus court
Problème :
I Le nombre de chemins peut être infini (dans le cas de cycles)
I Le nombre de chemins peut être exponentiel par rapport au nombre
de sommets et d’arêtes
s v1 v2 …" vn
(O(n) nœuds et 2n chemins entre s et vn )
Graphes 438
Schéma général d’un algorithme
Objectif : calculer v .d = δ(s, v ) pour tout v ∈ V
Idée d’algorithme :
I v .d à un itération donnée contient une estimation du poids d’un plus
court chemin de s à v
I Invariant : v .d ≥ δ(s, v )
I Initialisation : v .d = +∞ (∀v ∈ V )
I A chaque itération, on tente d’améliorer (c’est-à-dire diminuer) v .d
en maintenant l’invariant
I A la convergence, on aura v .d = δ(s, v )
I L’amélioration est basée sur l’utilisation de l’inégalité triangulaire
Graphes 439
Inégalité triangulaire et relâchement
Théorème : Pour tout u, v , x ∈ V , on a
δ(u, v ) ≤ δ(u, x) + δ(x, v )
Preuve : Aller de u à v en empruntant un plus court chemin passant

par x ne peut pas être plus court qu’un plus court chemin de u à v .
Corrolaire : Pour tout (u, v ) ∈ E , on a

24-4 Lecture Notes for Chapter 24: Single-Source Shortest Paths
δ(s, v ) ≤ δ(s, u) + w (u, v )

R ELAX .u; !; w/
if !:d > u:d C w.u; !/
Amélioration d’une arête (Relâchement)!:d: D u:d C w.u; !/
!:" D u
u v
Relax(u, v , w ) 4
3
10 4
3
6
RELAX RELAX
1 if v .d > u.d + w (u, v )
4 7 4 6
2 v .d = u.d + w (u, v )
Graphes
For all the single-source shortest-paths algorithm
440
Init-single-source(G , s)
Single-source-SP(G , w , s) 1 for each v ∈ G .V
1 Init-single-source(G , s) 2 v .d = ∞
2 while ∃(u, v ) : v .d > u.d + w (u, v ) 3 s.d = 0
3 Pick one edge (u,v)
4 Relax(u, v , w ) Relax(u, v , w )
1 if v .d > u.d + w (u, v )
2 v .d = u.d + w (u, v )
On obtient différents algorithmes en modifiant la manière dont on
sélectionne les arêtes
Graphes 441
Init-single-source(G , s)
1 for each v ∈ G .V
2 v .d = ∞
Single-source-SP(G , w , s) 3 v .π = NIL
1 Init-single-source(G , s) 4 s.d = 0
2 while ∃(u, v ) : v .d ≥ u.d + w (u, v )
3 Pick one edge (u,v) Relax(u, v , w )
4 Relax(u, v , w )
1 if v .d > u.d + w (u, v )
2 v .d = u.d + w (u, v )
3 v .π = u
En ajoutant la construction de l’arbre des plus courts chemins
Graphes 442
Propriétés de l’algorithme général
Propriété 1 : L’algorithme général maintient toujours l’invariant
Preuve : Par induction sur le nombre d’itérations

I Cas de base : l’invariant est vérifié après l’initialisation
I Cas inductif :
I Soit un appel à relax(u, v , w )
I Avant l’appel, on suppose que l’invariant est vérifié et donc
u.d ≥ δ(s, u)
I Par l’inégalité triangulaire :
δ(s, v ) ≤ δ(s, u) + δ(u, v )

≤ u.d + w (u, v )
I Suite à l’assignation v .d = u.d + w (u, v ), on a bien
v .d ≥ δ(s, v )
Graphes 443
Propriétés de l’algorithme général
Propriété 2 : Une fois que v .d = δ(s, v ), il n’est plus modifié

Preuve : On a toujours v .d ≥ δ(s, v ) et un relâchement ne peut que
diminuer v .d
Vu les propriétés 1 et 2, pour montrer qu’un algorithme du plus

court chemin est correct, on devra montrer que le choix des arêtes à
relâcher mènera bien à v .d = δ(s, v ) pour tout v .
Graphes 444
Algorithme de Bellman-Ford
Single-source-SP(G , w , s)
1 Init-single-source(G , s)
2 while ∃(u, v ) : v .d ≥ u.d + w (u, v )
3 Pick one edge (u,v)
4 Relax(u, v , w )
Algorithme basé sur la relâchement

Soit les arêtes e1 , . . . , em , dans un ordre quelconque.
Le relâchement se fait dans cet ordre :
e1 , e2 , . . . , em ; e1 , e2 , . . . , em ; . . . ; e1 , e2 , . . . , em
| {z } | {z } | {z }
| {z }
|V |−1fois
Graphes 445
for each edge .u; !/ 2 G:E
Algorithme de Bellman-Ford
if !:d > u:d C w.u; !/
return FALSE
Bellman-Ford(G
return TRUE , w , s)
2Core:
for i=1 to |G
The .V | − for
nested 1 loops relax all edges jV j ! 1
3 for each edge (u, v ) ∈ G .E
4Time: ‚.VE/.Relax(u, v , w )
Example
Illustration sur un exemple :
r
–1
–1 2
s 0 1 x
3 1 2
4 –3
2 –2
z 5 y
Graphes 446
Bellman-Ford(G , w , s)
2 for i=1 to |G .V | − 1
4 Relax(u, v , w )
La boucle principale relâche toutes les arêtes |V | − 1 fois

Complexité : Θ(|V | · |E |)
I En supposant qu’on puisse parcourir les arêtes en O(|E |)
Graphes 447
On supposera qu’il n’y a pas de cycle de poids négatif
Propriété 3 : Après i itérations de l’algorithme, v .d est le poids d’un
plus court chemin de s à v utilisant au plus i arêtes :
v .d ≤ min{w (p) : |p| ≤ i}
Preuve : Par induction :
I Cas de base : v .d = +∞ si i = 0 et s.d = 0
I Cas inductif :
I Avant l’itération i, on a v .d ≤ min{w (p) : |p| ≤ i − 1}
I Cette propriété reste vraie à tout moment de l’itération puisque
Relax ne peut que diminuer les v .d
I L’itération i considère tous les chemins avec i arêtes ou moins en
relâchant tous les arêtes entrantes en v
v
s …"
i 1 arêtes
Graphes 448
Si le graphe ne contient pas de cycles de poids négatif, alors, à la fin

de l’exécution de l’algorithme de Bellman-Ford, on a v .d = δ(s, v )
pour tout v ∈ V .
Preuve :
I Sans cycle négatif, tout plus court chemin est simple, c’est-à-dire
sans cycle
I Tout chemin simple a au plus |V | sommets et donc |V | − 1 arêtes
I Par la propriété 3, on a v .d ≤ δ(s, v ) après |V | − 1 itérations
I Par l’invariant, on a v .d ≥ δ(s, v ) ⇒ v .d = δ(s, v )
Graphes 449
Détection des cycles négatifs
Renvoie True si un cycle

Bellman-Ford(G , w , s) négatif (accessible depuis s)
1 Init-single-source(G , s) existe, False sinon
2 for i=1 to |G .V | − 1 En cas de cycle négatif, il
3 for each edge (u, v ) ∈ G .E existe toujours (et donc aussi
4 Relax(u, v , w )
en sortie de boucle) au moins
6 if v .d > u.d + w (u, v ) un v .d qu’on peut améliorer
7 return False par relâchement d’un arc
8 return true (u, v )
Graphes 450
Programmation dynamique
L’algorithme de Bellman-Ford implémente en fait une approche par

programmation dynamique3
Soit v .d[i], la longueur du plus court chemin de s à v utilisant au
plus i arêtes
On a
8
< 0 si v = s et i = 0
v .d[i] = +∞ si v 6= s et i = 0
min{v .d[i − 1], min(u,v )∈E {u.d[i − 1] + w (u, v )}} sinon
:
(Exercice : implémenter l’algorithme de Bellman-Ford à partir de la

récurrence et comparer le avec la version précédente)
3
Bellman est en fait l’inventeur de la programmation dynamique
Graphes 451
Graphe dirigé acyclique (DAG)
Single-source shortest paths in a directed acyclic graph
Version plus efficace dans le cas d’un graphe dirigé acyclique :
Since a dag, we’re guaranteed no negative-weight cycles.
DAG-Shortest-Path(G , w , s)
1DAG-S
L =HORTEST
Top-Sort(G
-PATHS).G; w; s/
2 topologically
Init-single-source(G
sort the vertices , s)
3 I NIT
for-Seach
INGLEvertex u, .G;
-S OURCE takens/ in their order in L
4 for eachfor eachu, vertex
vertex taken invtopologically
∈ G .Adj[u]sorted order
5 for each Relax(u, v, w)
vertex ! 2 G:AdjŒu"
R ELAX .u; !; w/
Exemple : Example
6 1
s t x y z
2 7 –1 –2
0 2 6 5 3
4
2
Time
Graphes ‚.V C E/. 452
Poids unitaires : parcours en largeur d’abord
On peut obtenir une solution plus rapide en imposant certaines
contraintes sur la nature des poids
Si les poids sont tous égaux à 1, le parcours en largeur permet de
calculer les v .d en O(|V | + |E |)
Rappel :
BFS(G , s)
1 for each vertex u ∈ G .V \ {s}
2 u.d = ∞
3 s.d = 0
4 Q =”create empty Queue”
5 Enqueue(Q, s)
6 while not Queue-Empty(Q)
7 u = Dequeue(Q)
9 if v .d = ∞
10 v .d = u.d + 1
11 Enqueue(Q, v )
Graphes 453
Poids unitaires : parcours en largeur d’abord
1 0 2 3
a s d f
2
1 3
z x c v
2
Graphes 454
Poids entiers, positifs et bornés
Si les poids sont des entiers compris entre 1 . . . W :
I On définit un nouveau graphe en éclatant chaque arête de poids w en
w arêtes de poids 1
I On applique le parcours en largeur sur ce nouveau graphe
Complexité : O(|V | + W |E |)
7
b f
3
5 5
s 8
c
5 2
d g
4
Graphes 455
Poids positifs : approche gloutonne
Algorithme de Dijkstra : généralisation du parcours en largeur à des

poids positifs réels
Idée :
I On maintient un ensemble S de sommets dont le poids d’un plus
court chemin à partir de s est connu
I A chaque étape, on ajoute à S un sommet v ∈ V \ S dont la distance
à s est minimale
I On met à jour, par relâchement, les distances estimées des sommets
adjacents à v
Graphes 456
Q D G:V // i.e., insert all vertices into Q
Algorithme de Dijkstra
while Q ¤ ;
u D E XTRACT-M IN .Q/
Dijkstra(G , w , s)
S D S [ fug
1 Init-Single-Source(G , s)
for each vertex ! 2 G:AdjŒu"
2 S =∅
R ELAX .u; !; w/
3 Q =”create an empty min priority queue from G .V ”
4 while not Empty(Q)! Looks a lot like Prim’s algorithm, but computing !:d,
5 u = Extract-Min(Q)
weights as keys.
6 S = S ∪ {u}
7
! Dijkstra’s algorithm can be viewed as greedy, since it al
for each v ∈ G .Adj[u]
8 Relax(u, est”
v , w )(“closest”?)
// ! Relax vertex in V !laSclé
doit modifier to de
addv todans
S. Q
Illustration sur un exemple :

Example
x
8
10 2
s 0 3 4 6 z
5 1
5
Graphes y 457
Si la file à priorité est implémentée par un tas (min), l’extraction et

l’ajustement de la clé sont O(log |V |)
Chaque sommet est extrait de la file à priorité une et une seule fois
⇒ O(|V | log |V |)
Chaque arête est parcourue une et une seule fois et entraı̂ne au plus
un ajustement4 de clé
⇒ O(|E | log |V |)
Total : O(|V | log |V | + |E | log |V |) = O(|E | log |V |)
I |E | log |V | domine |V | log |V | si le graphe est connexe
4
Similaire à un Heap-Decrease-Key
Graphes 458
Observations:
! u ¤ s, since s:d D ı.s; s/ D 0.
Théorème : l’algorithme de Dijkstra se termine avec v .d = δ(s, v )
pour tout v ∈ Therefore, s 2 S, so S ¤ ;.
!
V
Preuve :
! There must be some path s ! u, since otherwise u:d D ı
no-path property.
I Lorsqu’un nœud v est extrait de la pile, son v .d n’est plus modifié. Il
suffit donc
So, de montrer
there’s ques v!
a path .d u.
= δ(s, v ) lorsque v est extrait de Q
I Par l’invariant (propriété 1), on a v .d ≥p δ(s, v ) à tout moment
I Then there’s
Par l’absurde, a shortest
supposons path sun!nœud
qu’il existe u. u tel que u.d > δ(s, u)
lors de Just
son extraction et soit u le premier
before u is added to S, path p nœud satisfaisant
connects cette
a vertex in S (i.e.,
propriété.
V ! S (i.e., u).
I Soit y le premier nœud d’un plus court chemin de s à u qui se trouve
dans Q Let y be
avant first vertex
l’extraction dealong p that’s
u et soit x soninprédécesseur
V ! S, and let x 2 S be y
p2
s
S u
p1
x y
Graphes p1 p2 459
V ! S (i.e., u).
Let y be first vertex along p that’s in V ! S, and let x 2 S be y
p2
s
S u
p1
x y
p p
I PuisqueDecompose
u est le premier nœud
p into s !1violant
x!y l’invariant, on a x.d
!2 u. (Could have=xδ(s,
D x)s or y
I Par la propriété
or p2 may de have
sous-structure
no edges.)optimale, le sous-chemin de s à y
est un plus court chemin et y .d a été assigné à
x.d + w (x, y ) = δ(s, x) + w (x, y ) = δ(s, y ) lors de l’extraction de x
I Claim
On a donc y .d = δ(s, y ) ≤ δ(s, u) ≤ u.d
I Or, y .dy:d
≥ u.dD ı.s; y/ when
puisqu’on u is added
s’apprête to S.u de la file
à extraire
I D’où y .d = δ(s, y ) = δ(s, u) = u.d, ce qui contredit notre
Proof x 2 S and u is the first vertex such that u:d ¤ ı.s; u/ w
hypothèse
to S ) x:d D ı.s; x/ when x is added to S. Relaxed .x; y/ at
the convergence property, y:d D ı.s; y/.
Graphes 460
2 8
n 25.1
Pluspresents
court achemin
dynamic-programming
pour toutesalgorithm les paires based
de on matrix multi-
sommets
on to solve
–4 the all-pairs shortest-paths
7 1
–5 problem. Using the technique of “re-
squaring,” we can achieve a running time of ‚.V lg V /. Section 25.2 gives
3
Déterminer 5 les plus courts 4 chemins pour toutes les paires de sommets :
r dynamic-programming 6 algorithm, the Floyd-Warshall algorithm, which
n time ‚.V /. Section 25.2 also covers
Entrées
3 : un graphe dirigé G = (Vthe , E ),problem of finding
une fonction the tran-
de poids w . Les
closure of a directed
sommets !0
sont graph,
3
numérotés
8 1 !4
de ˘1 à n !
which is related to the0all-pairs 3 8 2 !4
˘
shortest-paths
m. Finally, Section
Sortie :1une25.30 presents
1 D1 =Johnson’s
matrice (d algorithm,
7 ij ) de taille n ×3n où which =solves
0 dij!4 1 j)the
δ(i, all-
7pour
hortest-paths
tous
L.1/ problem
Chapter 25 4 in
1 All-Pairs
D sommets j 12 lg
0Shortest
i etO.V Paths
1V C VE/ L.2/ time
D and
1 is4a good 0 5choice11 for
sparse graphs. 2 1 !5 0 1 2 !1 !5 0 !2
ore proceeding, we need 2 to establish some conventions for adjacency-matrix
1 1 1 6 0 8 1 1 6 0
entations. First, 3we! shall generally

3 !3 2 !4
4 ˘ !
assume that the 0input1 graph ˘
G D .V; E/
!3 2 !4
vertices, so1that 3n D 0jV !4 j. Second, we shall use the convention
0 !4 1of !1 denoting
0
1 !13 3
8
es by uppercase
.3/
L D 27letters,
4 such 0 5as W 11 , L, orLD, D .4/ and their7 4individual
0 5 elements
3
scripted lowercase
–4
2 letters,
!1 !5 such 0 !2
–5 as w ,
ij ij l , or d ij . Some
2 !1 matrices
!5 0 will
!2 have
87 5 1 1 6.m/ 0 ! .m/ " 5 ! .m/1 "6
hesized superscripts, as in L D lij or D D dij , to indicate
.m/8 0
5 4
s. Finally, for a given 6n ! n matrix A, we shall assume that the value of n is
Figure 25.1
in the attribute A directed graph and the sequence of matrices L.m/ computed by S LOW-A LL
0
!
A:rows.
3 8 1 !4
˘ 0 3
! 8 2 !4
˘
S HORTEST-PATHS. You might want to verify that L , defined as L " W , equals L , a
.5/ .4/ .4/
for all0m #
L.m/ D L.4/ 1 1 4. 1 7 3 0 !4 1 7
Graphes .1/ .2/ 461
Plus court chemin pour toutes les paires de sommets
Dans le cas général, on peut appliquer Bellman-Ford sur chaque

sommet
I O(|V |2 |E |), ou O(V 4 ) si le graphe est dense (E = Θ(V 2 ))
S’il n’y a pas de poids négatifs, on peut appliquer Dijkstra sur

chaque sommet
I O(|V ||E | log |V |), ou O(V 3 log |V |) si le graphe est dense
Il est possible d’obtenir O(V 3 ) par programmation dynamique
Graphes 462
Floyd-Warshall algorithm
Une solution par programmation dynamique
Pour un chemin p = hvdynamic-programming
A different 1 , v2 , . . . , vl i, un sommetapproach.
intermédiaire est un
sommet de p autre que v1 ou vl
(k)
For path p D h!1 ; !2 ; : : : ; !l i, an intermediate vertex is an
Soit dij le! poids d’un plus court chemin entre i et j tel que tous les
1 or !l .
sommets intermédiaires sont dans le sous-ensemble de sommets
Let dij.k/ D shortest-path weight of any path i ! j with
{1, 2, . . . , k}
Soit un plus in court
f1; 2; chemin
: : : ; kg.p entre i et j avec tous les sommets dans
{1, 2, . . . , k} : p
Consider a shortest path i ! j with all intermediate verti
I Si k n’est pas un sommet intermédiaire de p, alors tous les sommets
intermédiaires
! If k deispnot
sontan
dans {1, 2, . . . , k −vertex,
intermediate 1} then all intermedi
I Si k est un sommet intermédiaire, tous les sommets intermédiaires
f1; 2; : : : ; k ! 1g.
des sous-chemins entre i et k et entre k et j appartiennent à
{1, 2, .!. . , If is an intermediate vertex:
k −k 1}
p1 p2
i k j
all intermediate vertices in {1, 2, ..., k–1}

Graphes 463
Algorithme de Floyd-Warshall
Formulation récursive :
(
(k) w (i, j) si k = 0,
dij = (k−1) (k−1) (k−1)
min(dij , dik + dkj ) si k ≥ 1.
Implémentation ascendante : Θ(|V |3 )

I W = (wij ) est la matrice d’adjacence pondérée
I wij = w (i, j) si (i, j) ∈ E , +∞ sinon
Floyd-Warshall(W , n)
1 D (0) = W
2 for k = 1 to n
(k)
3 let D (k) = (dij ) be a new n × n matrix
4 for i = 1 to n
5 for j = 1 to n
(k) (k−1) (k−1) (k−1)
6 dij = min(dij , dik + dkj )
(n)
7 return D
Graphes 464
Fermeture transitive d’un graphe
Soit un graphe dirigé G = (V , E ). La fermeture transitive de G est
le graphe G ∗ = (V , E ∗ ) tel que :
E ∗ = {(i, j) : ∃ un chemin de i à j dans G }
Exemple :
Solution directe :
I Assigner un poids wij = 1 à toute arête (i, j) ∈ E
I Appliquer l’algorithme de Floyd-Warshall
I Si dij < ∞, il y a un chemin entre i et j dans G
I Sinon, dij = ∞ et il n’y a pas de chemin
Graphes 465
Fermeture transitive d’un graphe
Une solution plus simple en modifiant l’algorithme de Floyd-Warshall :

(k)
Soit tij = 1 s’il y a un chemin de i à j avec tous les nœuds
intermédiaires dans {1, 2, . . . , k}, 0 sinon
On a :

 0 si k = 0, i 6= j et (i, j) ∈
/E
(k)
tij = 1 si k = 0 et i = j ou (i, j) ∈ E
 (k−1) (k−1) (k−1)
tij ∨ (tik ∧ tkj ) si k ≥ 1.
Même implémentation que Floyd-Warshall

I on remplace min par ∨ et + par ∧
Graphes 466
Fermeture transitive d’un graphe : algorithme
Transitive-closure(G , n)
(0)
1 Let T (0) = (tij ) be a new n × n matrix
2 for i = 1 to n
3 for j = 1 to n
4 if i == j or (i, j) ∈ G .E
(0)
5 tij = 1
(0)
6 else tij = 0
7 for k = 1 to n
(k)
8 let T k = (tij ) be a new n × n matrix
9 for i = 1 to n
10 for j = 1 to n
(k) (k−1) (k−1) (k−1)
11 tij = tij ∨ (tik ∧ tkj )
(n)
12 return D
Complexité : Θ(|V |3 )
I Idem Floyd-Warshall mais opérations plus simples
Graphes 467
Plus court chemin : synthèse
Origine unique, graphe dirigé acyclique :

I Relâchement en suivant un ordre topologique
I Θ(|V | + |E |)
Origine unique, graphe dirigé, poids positifs :
I Algorithme de Dijkstra
I Θ(|E | log |V |)
Origine unique, graphe dirigé, poids quelconques :
I Algorithme de Bellman-Ford
I Θ(|V | · |E |)
Toutes les paires, graphe dirigé ou non :
I Algorithme de Floyd-Warshall
I Θ(|V |3 )
Graphes 468
Plan
1. Définitions
5. Arbre couvrant
Graphes 469
Arbre couvrant
Définition : un arbre couvrant (spanning tree) pour un graphe
connexe (V , E ) non dirigé est un arbre (i.e. un graphe acyclique) T
tel que :
I l’ensemble des nœuds de T est égal à V , et
I l’ensemble des arcs de T est un sous-ensemble de E
Construction : par un parcours en largeur ou en profondeur (graphe
de liaison)
Exemple
Graphes 470
Model as a graph:
Arbre couvrant de poids minimum
Undirected graph G D .V; E/.
!
! Weight w.u; !/ on each edge .u; !/ 2 E.

! Find T ! E such that
Définition : un arbre couvrant de poids minimum, ACM, (minimum
spanning tree, MST) 1. pour un graphe
T connects pondéré(Tconnexe
all vertices (V , E )tree),
is a spanning est un
and
arbre (V , E 0 ) tel que :2. w.T / D
X
w.u; !/ is minimized.
I (V , E 0 ) est un
P arbre couvrant .u;!/2T
de (V , E ), et
I la valeur de e∈E 0 w (e) est minimale parmi tous les arbres couvrant
de (V , E ), où wA(e)
spanning
dénotetree whose
le poids deweight
l’arc e is minimum over all spannin
imum spanning tree, or MST.
Example of such a graph [edges in MST are shaded] :
Exemple :
8 8
b d g
10 2
7 5
a 9 e 9 i
3 3
12 11
c f h
1 6
In this example, there is more than one MST. Replace ed

by .c; e/. Get a different spanning tree with the same weigh
Graphes 471
Applications
Conception de réseaux : connecter des entités en minimisant le coût

de la connection
I Raccorder des maisons à un central téléphonique en minimisant les
longueurs de cables
I Elaborer un système routier pour connecter des maisons
I ...
Dissémination de contenu/routage sur internet
Design de circuits imprimés
...
Graphes 472
Approche générique
Idée :
I Un ACM est un sous-ensemble d’arêtes du graphe initial
I On démarre avec un ensemble d’arêtes A = ∅ vide
I On ajoute dans A des arêtes en respectant l’invariant suivant :
I Il existe un ACM qui contient les arêtes de A
I S’il existe un ACM contenant les arêtes de A, une arête (u, v ) est
sûre pour A ssi il existe un ACM contenant les arêtes de A ∪ {(u, v )}
Algorithme générique :
Generic-MST(G , w )
1 A=∅
2 while A is not a spanning tree
3 find an edge (u, v ) that is safe for A
4 A = A ∪ {(u, v )}
5 return A
Comment trouver des arêtes sûres ?

Graphes 473
Arêtes sûres
Soit S ⊂ V et A ⊆ E :
I Une coupure (cut) (S, V \ S) est une partition des sommets en deux
ensembles disjoints S et V \ S
I Une arête traverse (crosses) une coupure (S, V \ S) si une extrémité
est dans S et l’autre dans V \ S
I Une coupure respecte A ssi il n’y a pas d’arête dans A qui traverse la
coupure
Théorème : Soit A un sous-ensemble d’un ACM, (S, V \ S) une

coupure qui respecte A et (u, v ) une arête de poids minimal qui
traverse la coupure (S, V \ S). (u, v ) est sûre pour A.
(Propriété des choix gloutons optimaux)
Graphes 474
contains a unique path p between u and !. Path p must cross the cu
at least once. Let .x; y/ be an edge of p that crosses the cut. F
Arêtes sûres chose .u; !/, must have w.u; !/ " w.x; y/.
x
u
v
y
Preuve : V–S
Soit T un ACM qui inclut A

[Except for the dashed edge .u; !/, all edges shown are in T . A is so
Supposons que T ne contienne pas (u,of vT ,)butetA cannot
the edges montrons
contain anyqu’il est
edges that cross the cut .S; V
possible de construire un arbre TSince 0 cut
this
qui inclut A ∪ {(u, v )}
respects A. Shaded edges are the path p .]
the cut respects A, edge .x; y/ is not in A.
Puisque T est un arbre, il n’y a To qu’un
form T unique
from T : 0 chemin p entre u et v
et ce chemin traverse la coupure (S, V .x;
Remove ! \ S).
y/. Breaks T into two components.
Soit (x, y ) une arête de p qui traverse la coupure (S, V \ S)

Add .u; !/. Reconnects.
!
Puisque (u, v ) est l’arête de poids minimum qui traverse la coupure,

on a :
w (u, v ) ≤ w (x, y )
Graphes 475
contains a unique path p between u and !. Path p must cross the cut .S; V ! S/
at least once. Let .x; y/ be an edge of p that crosses the cut. From how we
Arêtes sûres chose .u; !/, must have w.u; !/ " w.x; y/.
x
u
v
y
V–S
[Except for the dashed edge .u; !/, all edges shown are in T . A is some subset of
Puisque la coupure respecte
the edges of T ,A,
but Al’arête (x,any
cannot contain y )edges
n’est pasthedans
that cross cut .S; VA! S/, since
0
Soit T = (T \ {(x, y )}) ∪ {(u, v )} :
this cut respects A. Shaded edges are the path p .]
Since the cut respects A, edge .x; y/ is not in A.
I T 0 est un spanning tree
To form T 0 from T :
I w (T 0 ) = w (T ) − wRemove
!
(x, y.x;)+ w (u, v ) ≤ w (T ) puisque
y/. Breaks T into two components.
w (u, v ) ≤ w (x, y ) Add .u; !/. Reconnects.
!
T0est donc bien un ACM tel que A ∪ {(u, v )} ⊆ T 0

⇒ (u, v ) est sûre pour A
Graphes 476
Algorithme de Kruskal
Approche gloutonne :
I On construit incrémentalement une forêt (c’est-à-dire, un ensemble
d’arbres), en ajoutant progressivement des arêtes à un graphe
initialement dépourvu d’arcs
I On maintient en permanence une partition du graphe en cours de
construction en ses composantes connexes
I Pour relier des composantes connexes, on choisit à chaque fois l’arête
de poids minimal qui les connecte
I On s’arrête dès qu’il ne reste plus qu’une composante connexe
Correction :
I Puisqu’on connecte à chaque fois deux composantes connexes
disjointes, le graphe reste acyclique et à la terminaison, on obtient un
arbre couvrant
I Puisqu’on sélectionne une arête de poids minimal à chaque étape, le
théorème précédent garantit qu’on arrivera à un ACM
Graphes 477
Algorithme de Kruskal
Kruskal(G , w )
1 A=∅
2 P=∅
3 for each vertex v ∈ G .V
4 P = P ∪ {{v }}
5 for each (u, v ) ∈ G .E taken into nondecreasing order of weight w
6 P1 = subset in P containing u
7 P2 = subset in P containing v
8 if P1 6= P2
9 A = A ∪ {(u, v )}
10 Merge P1 and P2 in P
11 return A
Les choix des composantes connexes à combiner est arbitraire

On fixe cet ordre en parcourant les arêtes par ordre croissant
Graphes 478
Illustration
8 8
b d g
10 2
7 5
a 9 e 9 i
3 3
12 11
c f h
1 6
P
In this example, there is more than one MST. Replace edge .
by .c; e/.{{a},
Get {b}, {c}, {d},
a different {e}, {f },tree
spanning {g },with
{h},the
{i}}same weight.
(c, f ) fusion {{a}, {b}, {c, f }, {d}, {e}, {g }, {h}, {i}}
(g , i) fusion {{a}, {b}, {c, f }, {d}, {e}, {g , i}, {h}}
(e, f ) fusion {{a}, {b}, {c, f , e}, {d}, {g , i}, {h}}
(c, e) rejet
(d, h) fusion {{a}, {b}, {c, f , e}, {d, h}, {g , i}}
(f , h) fusion {{a}, {b}, {c, f , e, d, h}, {g , i}}
(e, d) rejet
(b, d) fusion {{a}, {b, c, f , e, d, h}, {g , i}}
(d, g ) fusion {{a}, {b, c, f , e, d, h, g , i}}
(b, c) rejet
(g , h) rejet
(a, b) fusion {{a, b, c, f , e, d, h, g , i}}
Graphes 479
Implémentation
Problème : comment représenter les partitions de l’ensemble des

sommets du graphe ?
Une solution possible :
I On numérote les parties P1 , P2 ,. . . , Pk d’une partition
{P1 , P2 , . . . , Pk } à l’aide des nombres de 1 à k
I Pour chaque sommet v , on retient le numéro de la partie à laquelle il
appartient (attribut v .p)
I Pour chaque numéro de partie, on retient une liste des sommets
contenus dans cette partie
I Lors de la fusion de deux parties, on insère la plus petite partie à
fusionner dans l’autre et on met à jour les numéros de partie
Complexité :
I Trouver la partie associée à un sommet : O(1)
I Fusionner deux parties de tailles n1 et n2 , avec n1 < n2 : Θ(n1 )
Graphes 480
Complexité
Initialisation : O(|V |)
Tri des arêtes : O(|E | log |V |)
I Tri : O(|E | log |E |)
I Or, |E | < |V |2 ⇒ log |E | = O(2 log |V |) = O(log |V |)
Coût total des fusions : O(|V | log |V |)
I Chaque fusion est linéaire par rapport à la taille de la plus petite partie
I Chaque fusion produit un nouvelle partie au moins deux fois plus
grande que la plus petite
I Chaque sommet n’est ajouté à une partie qu’au plus O(log |V |) fois
Temps d’exécution total :
O(|E | log |V | + |V | log |V |) = O(|E | log |V |)
I Car |E | domine |V | dans le cas d’un graphe connexe
Graphes 481
Algorithme de Prim
Principe :
I A est toujours un arbre (plus une forêt)
I Initialisé comme une seule racine r choisie de manière arbitraire
I A chaque étape, choisir une arête de poids minimal traversant la
coupure (VA , V \ VA ), où VA est l’ensemble des sommets connectés
par des arêtes de A, et l’ajouter à A.
Prim(G , w , r )
1 A=∅
2 VA = {r }
3 while |VA | < |G .V |
4 (u, v ) =”an edge of minimal weight from VA to V \ VA ”
5 VA = VA ∪ {u, v }
6 A = A ∪ {(u, v )}
7 return A
Correction : toujours en application du théorème

Graphes 482
Implémentation
Comment extraire efficacement l’arête de poids minimal ?

Utiliser une file à priorité :
I Chaque élément de la file est un sommet de V \ VA (pas encore
couvert par l’arbre courant)
I La clé de v est le poids minimum de tout arête (u, v ) où u ∈ VA
I Cette clé est mis à jour à chaque ajout d’un sommet dans VA
L’arbre est “stocké” par le biais d’un pointeur v .π

I v .π est le parent de v dans l’arbre couvrant minimal
I v .π = NIL si v = r ou v n’a pas de parents
Graphes 483
Implémentation
Prim(G , w , r )
1 Q=∅
2 for each u ∈ G .V
3 u.key = ∞
4 u.π = NIL
5 Insert(Q, u)
6 Decrease-key(Q, r , 0) // r .key = 0
7 while Q 6= ∅
8 u = Extract-min(Q)
10 if v ∈ Q and w (u, v ) < v .key
11 v .π = u
12 Decrease-Key(Q, v , w (u, v ))
Graphes 484
Illustration
8 8
b d g
10 2
7 5
a 9 e 9 i
3 3
12 11
c f h
1 6
A partir du nœud dIn this example, there is more than one MST. Replace edge .
Nœud by0 .c;Qe/.
Q 1 Get2a different
Q Q 3 Q spanning
4
Q 5 tree
Q 6 with
Q 7 theQsame
8 weight.
a ∞ ∞ ∞ ∞ 12 12 10 10 10
b ∞ 8 8 8 8 8
c ∞ ∞ ∞ 1
d 0
e ∞ 7 7 3 3
f ∞ ∞ 6
g ∞ 8 8 8 8 8
h ∞ 5
i ∞ ∞ 11 11 11 11 2
(valeurs de clé des sommets dans Q au fur et à mesure des itérations)
Graphes 485
Complexité
En supposant que Q est implémentée à l’aide d’un tas (min)

Initialisation et première boucle for : O(|V | log |V |)
Diminuer la clé de r : O(log |V |)
Boucle while : O(|V | log |V | + |E | log |V |)
I |V | appels à Extract-Min ⇒ O(|V | log |V |)
I |E | appels à Decrease-Key ⇒ O(|E | log |V |)
Temps d’exécution total :
O(|E | log |V | + |V | log |V |) = O(|E | log |V |)
I Car |E | domine |V | dans le cas d’un graphe connexe
Graphes 486
Fin
Pour aller plus loin :
Graphes 487

Sda Complet 2011 2012

Transféré par

Droits d'auteur :

Formats disponibles

Sda Complet 2011 2012

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Sda Complet 2011 2012

Transféré par

Droits d'auteur :

Formats disponibles

Structures de données et algorithmes

Introduction à l’étude systématique des algorithmes et des structures

Ce cours s’inspire également de plusieurs cours disponibles sur le web :

1. Algorithms + Data structures = Programs (Niklaus Wirth)

Un algorithme est une suite finie et non-ambiguë d’opérations ou

On étudiera essentiellement les algorithmes corrects.

Les algorithmes seront évalués en termes d’utilisation de resources,

Un algorithme peut être spécifié de différentes manières :

Description en langage naturel :

On parcourt la séquence de gauche à droite

Pour chaque élément aj :

Intro to Data Structures and Algorithms © Introdu

Description en C (sur des tableaux d’entiers) :

void InsertionSort (int *a, int length) {

Description en pseudo-code (sur des tableaux d’entiers) :

Rendre la description indépendante de l’implémentation

S’affranchir de détails tels que la gestion d’erreurs, les déclarations

Très proche du C (langage procédural plutôt qu’orienté objet)

Peut contenir certaines instructions en langage naturel si nécessaire

Les variables (i, j et key par exemple) sont locales à la fonction.

1. Mon algorithme est-il correct, se termine-t-il ?

2. Quelle est sa vitesse d’exécution ?

3. Y-a-t’il moyen de faire mieux ?

Exemple du tri par insertion

Invariant : (pour la boucle externe) le sous-tableau A[1 . . j − 1]

Avant la première itération :

Avant la jème itération :

Nombre de comparaisons T (n) pour trier un tableau de taille n ?

Le nombre de comparaisons est borné par :

Méthode pour stocker et organiser les données pour en faciliter

Un type de données abstrait (TDA) représente l’interface d’une

Il existe de nombreuses façons d’implémenter ce TDA :

1. Algorithms + Data structures = Programs (Niklaus Wirth)

Motivation : Simplicité d’expression de certains algorithmes

Exemple : Fonction factorielle :

Règles pour développer une solution récursive :

On doit définir un cas de base (n == 0)

Calcul du kième nombre de Fibonacci :

1. L’algorithme est-il correct ?

1. L’algorithme est correct ?

Toutes les implémentations atteignent leur limite, plus ou moins loin

fibonacci1(k 4) fibonacci1(k 3) fibonacci1(k 3) fibonacci1(k 2)

Soit T (n) le nombre d’opérations de base pour calculer

On a donc T (n) ≥ Fn (= le nème nombre de Fibonacci).

Comment croı̂t Fn avec n ?

T (n) ≥ Fn = Fn−1 + Fn−2

Puisque Fn ≥ Fn−1 ≥ Fn−2 ≥ . . .

Peut-on faire mieux ?

Appel initial : merge-sort(A, 1, A.length)

Exemple d’application du principe général de “diviser pour régner”

n1=q-p+1 elem. n2=r-q elem.

Abefore ... ...

Aafter ... ...

n = r-p+1 elements Data Structures and Algorithms (89)

Complexité : O(n) (où n = r − p + 1)

Complexité de merge-sort : O(n log n) (voir partie 2)

La fonction merge nécessite d’allouer deux tableaux L et R (dont

En e↵et, chaque appel récursif de factorial nécessite de mémoriser son

Définition : Une procédure est récursive terminale (tail récursive) si