Handout1 7s

Plan
1 Introduction
2 Complexité des Algorithmes

Calculabilité, Combinatoire et 3 Analyse Asymptotique
Complexité 4 Représentation des Données
5 Combinatoire et Dénombrement
Complexité des Algorithmes
6 Quelques Notions de Graphe
Emmanuel Hebrard 7 Algorithmes Récursifs
2 / 99
Question d’un entretien d’embauche chez Google
Introduction
Soit un histogramme avec n barres sur lequel on a versé un volume d’eau infini.
I Donnez un algorithme pour calculer le volume d’eau résiduel en temps linéaire.
Introduction 3 / 99 Introduction 4 / 99
Complexité des algorithmes Trois problèmes de pavage
Les trois problèmes ci-dessous sont-ils faciles ? Difficiles ?
Problème 1 : (Tetris)
Etant donné une position de Tetris et la liste des pièces à venir, est-ce qu’il
est possible de vider l’écran ?
Savoir analyser l’efficacité d’un algorithme
Savoir développer des algorithmes efficaces
Trois problèmes de pavage Trois problèmes de pavage
Les trois problèmes ci-dessous sont-ils faciles ? Difficiles ? Les trois problèmes ci-dessous sont-ils faciles ? Difficiles ?
Problème 1 : (Tetris) Problème 1 : (Tetris)

Etant donné2 une
Problème position en
: (Portrait de dominos)
Tetris et la liste des pièces à venir, est-ce qu’il Etant donné2 une
Problème position en
: (Portrait de dominos)
Tetris et la liste des pièces à venir, est-ce qu’il
est possible de vider l’écran ? est possible de vider l’écran ?
Etant donné n jeux de dominos et une image, trouver le pavage qui Etant donné3 n: (Dominos
Problème jeux de dominos et une image, trouver le pavage qui
de Wang)
reproduit l’image au mieux reproduit l’image au mieux
Etant donné un ensemble fini de dominos de Wang, est-ce qu’il existe un
pavage du plan ?
Calculabilité et complexité des problèmes Vaincre la Combinatoire : Algo. ou Matériel ?
Problème du Voyageur de Commerce

donnée : ensemble de villes
question : quel est le plus court chemin passant par toutes les villes ?
Portrait en dominos est “facile” (il existe un algorithme efficace)
Méthode “Brute-force” : trois instructions par nano seconde
Un ordinateur plus rapide : une instruction par temps de Planck (5.39 × 10−44 s)
Tetris est “difficile” (il n’existe –probablement– pas d’algorithme efficace) Un ordinateur plus parallèle : remplissons l’univers de processeurs d’un mm3
donnée processeur 3 GHz processeur de Planck massivement parallèle
10 villes 1/100s
Dominos de Wang est “incalculable” (il n’existe pas d’algorithme) 15 villes 1 heure
19 villes 1 an
27 villes 8 × âge de l’univers
35 villes ? 5/1000s
40 villes ? 12 heures
50 villes ? 4000 × âge de l’univers temps de planck
95 villes ? ? 3 × âge de l’univers
Problème, Donnée & Algorithme
Définition : Problème ' fonction sur les entiers

1 1
 
2 4
Une question Q qui associe une donnée x à une réponse y 

 3 9



I “Quel est le plus court chemin de x1 vers x2 par le réseau R ?”
 4 16 
... ...
I “Quel est la valeur du carré de x ?”
Complexité des Algorithmes Toute donnée peut se coder par un Nombre de Gödel
Q est une relation, pas toujours une fonction : plus court(s) chemin(s)
On peut se restreindre aux fonctions
Algorithme : méthode pour résoudre un problème

Composée d’instructions primitives : exécutable par une machine
Correct (calcule la bonne réponse pour toute valeur de la donnée)
Déterministe : une seule exécution possible pour chaque donnée
Complexité des Algorithmes 9 / 99 Complexité des Algorithmes 10 / 99

Complexité Algorithmique : Problématique Le temps d’exécution
On veut être capable de : Le temps d’exécution

Évaluer l’efficacité d’un algorithme ;
Le temps d’exécution est la durée (en secondes, minutes, etc.) nécessaire
Comparer deux algorithmes entre eux ;
au programme pour s’éxecuter.
... sans les implémenter ! ! ! !
Mais le temps d’éxecution dépend :
Question de la machine ;
Qu’est ce qu’un algorithme efficace ? du système d’exploitation ;
Quels critères utiliser ? du langage ;
I longueur du code ; de la donnée ;
I temps d’exécution ;
I espace mémoire utilisé ;
On veut une méthode indépendante de l’environnement.
Nombre d’opérations élémentaires (I) Exemple
L’algorithme suivant calcule n! = n × (n − 1) × (n − 2) × · · · × 2 × 1 (avec 0! = 1).
Opération élémentaire nombre coût

Algorithme : Factorielle(n)
Une opération élementaire est une opération qui prend un temps constant
Données : un entier n
Même temps d’exécution quelque soit la donnée Résultat : un entier valant n!
1 fact : entier;
2 début initialisation : 1× 1 op.
3 fact ← 1;
Exemples d’opérations en temps constant 4 pour i allant de 2 à n faire itérations : n× 1 op.
5 fact = fact ∗ i; mult. + affect. : (n − 1)× 2 op.
Instructions assembleur
6 retourner fact; retour fonction : 1× 1 op.
Opérations arithmétiques (+, ×, −), affectation, comparaisons sur les types primitifs
(entiers, flottants, etc.)
Nombre total d’opérations :
1 + n + (n − 1) ∗ 2 + 1 = 3n

Exemple : TriSélection Exemple : TriSélection
L’algorithme suivant trie un tableau T de n éléments.

nombre coût
Algorithme : TriSélection
Données : tableau T d’elts comparables
Algorithme : TriSélection Invariants : Résultat : le tableau trié
Données : tableau T de n éléments A l’itération i : 1 début
comparables T [1] ≤ . . . ≤ T [i] et 2 pour i allant de 1 à n faire itérations : n× 1 op.
Résultat : le tableau trié i ≥ 1 =⇒ T [i] ≤ T [k] ∀k > i 3 m ← i; affectation : n× 1 op.
1 début 4 pour j allant de i + 1 à n faire itérations :
P n
(n−i −1)× 1 op.
5 si T [j] < T [m] alors Pi=1
n
2 pour i allant de 1 à n faire donnée 29 30 17 9 0 24 comparaison : i=1 (n−i −1)× 1 op.
3 m ← i; 6 m ← j; affectation : n×?× 1 op.
4 pour j allant de i + 1 à n faire i =1 0 30 17 9 29 24
|{z} 7 échanger T [i] et T [m];
5 si T [j] < T [m] alors trié échange : 3 op.
6 m ← j; i =2 0 9 17 30 29 24
| {z }
trié
7 échanger T [i] et T [m]; i =3 0 9 17 30 29 24 Nombre total d’opérations :
| {z }
trié n
i =4 0 9 17 24 29 30 X
| {z } n(n + 4) ≤ n + n + 2 (n − i − 1) + ? + 3n ≤ n(2n + 5)
trié i=1
Exemple : TriRapide Nombre d’opérations élémentaires (II)
Algorithme : TriRapide
Invariants Le nombre d’opérations dépend en général de la donnée du problème ;
Données : tableau T d’elts comparables, entiers s, e
Résultat : le tableau trié entre les indices s et e I T [0], . . . , T [i − 1] < pivot
Exemple :
1 Procedure TriRapide(T , s, e) I T [i], . . . , T [j − 1] ≥ pivot
2 si s < e alors
3 p ← Partition(T , s, e); (a) trier 10 entiers vs. trier 1000000 entiers
4 TriRapide(T , s, p − 1);
TriRapide(T , p + 1, e);
(b) tri par sélection de 1000 entiers déjà triés vs. 500 entiers triés dans
5
29 30 17 9 0 24 pivot le sens inverse
6 Procedure Partition(T , s, e)
7 pivot ← T [e];
8 i ← s; 17 9 0 29 30
9 pour j allant de s à e − 1 faire (a) ⇒ Donner la complexité en fonction de la taille de la donnée ;
10 si T [j] < pivot alors → nombre de bits de sa représentation en mémoire
11 échanger T [i] avec T [j];
12 i ← i + 1; 9 17 29 (b) ⇒ Plusieurs types de complexités peuvent être calculées
13 échanger T [i] avec T [j]; → pire/meilleur cas ou en moyenne.
14 retourner i;
9

Complexité en fonction de la taille de la donnée Exemple (Recherche dans un tableau)
Soit CoûtA (x) la complexité de l’algorithme A sur la donnée x de taille n.

Complexité dans le meilleur des cas L’algo. suivant recherche l’élément e dans un tableau.
InfA (n) = min{CoûtA (x) | x de taille n} Le nombre de comparaisons dépend

Algorithme : RechercheElmt(T , e) de la donnée T :
Données : un entier e et un tableau T e est dans la case 1 → 1 comp.
Complexité dans le pire des cas contenant e e est dans la case j → j comp.
Résultat : l’indice i t.q. T [i] = e
SupA (n) = max{CoûtA (x) | x de taille n} e est dans la case n → n comp. (n :
i : entier;
taille de T )
début
i ←0;
Complexité en moyenne tant que T [i] 6= e faire meilleur : 1 comp.
Besoin d’une probabilité P() pour toutes les données de tailles n i ← i + 1;
pire : n comp.
retourner i;
X n+1
MoyA (n) = P(x) · CoûtA (x) moyenne : 2 (voir slide suivant)
x de taille n
Complexité en moyenne (Recherche) Complexité en moyenne (TriSélection)
L’algo. suivant recherche l’élément e dans un tableau. InfTriSelection (n) = n(n + 4), SupTriSelection (n) = n(2n + 5)
Le temps de calcul T (n) de TriSélection pour n élément est tel que :

Algorithme : RechercheElmt(T,e) Hyp. :
Données : un entier e et un tableau T c1 · (n2 + 4n) ≤ T (n) ≤ c2 · (2n2 + 5n)
contenant e distribution uniforme
Résultat : l’indice i t.q. T [i] = e Les valeurs des constantes c1 et c2 dépendent de :
nbOcc(e) = 1
i : entier; I Le coût exact des opérations (comparaisons, affectations, etc.)
début
i ←0;
⇒ P(T [i] = e) = 1/n. I Le matériel (processeur, RAM, etc.)
I Le logiciel (langage, compilateur, système d’exploitation, etc.)
tant que T [i] 6= e faire
i ← i + 1; On applique la formule : Impossible à quantifier !
retourner i; X
MoyA (n) = P(x)·CoûtA (x) Les variations de c1 et c2 sont plus importantes que le facteur (inférieur à 2) entre
x de taille n n2 + 4n et 2n2 + 5n
n+1 InfTriSelection (n) ' MoyTriSelection (n) ' SupTriSelection (n) ' cn2
moyenne : 2 1 n(n + 1)
MoyA (n) = ×
n 2
Complexité dans le pire des cas (TriRapide) Complexité en moyenne (TriRapide)
Algorithme : TriRapide Algorithme : TriRapide

.. .. TriRapide fait un nombre constant (disons c1 )
. Pire des cas : les éléments sont déja triés ! . d’opérations pour chaque comparaison
Procedure Partition(T , s, e) Le pivot est comparé aux n − 1 éléments et Procedure Partition(T , s, e) I Au plus un échange et entre 1 et 2
pivot ← T [e]; pivot ← T [e]; incrémentation(s)
reste en dernière position
i ← s; i ← s;
pour j allant de s à e − 1 faire Nombre total de comparaisons : pour j allant de s à e − 1 faire Deux éléments sont comparés une fois au plus
si T [j] < pivot alors si T [j] < pivot alors
n n I Si deux éléments sont comparés, un des deux est
échanger T [i] avec T [j]; X X échanger T [i] avec T [j];
(n − i)1 = n2 − i = n(n − 1)/2 un pivot, et ils seront séparés
i ← i + 1; i ← i + 1;
i=1 i=1
On calcule l’espérance E du nombre total de
échanger T [i] avec T [j]; échanger T [i] avec T [j];
comparaisons
retourner i; retourner i;
Complexité en moyenne (TriRapide) Résumons
z1 z2 z3 z4 z5 z6 z7 z8 z9 TriSélection TriRapide
Sup(n) c1 n 2 c2 n 2
Moy(n) c3 n 2 c4 n ln n
Soit la liste triée des éléments de T : z1 < z2 < . . . < zn
Si on note p(zi , zj ) la probabilité que zi et zj soient comparés, alors l’espérance E du
Soient :
nombre de comparaisons est donc :
I T s (n) le temps effectif de calcul pour TriSélection de n éléments, ' Moys (n) = c3 n2
n−1 X
X n I T r (n) le temps effectif de calcul pour TriRapide de n éléments, ' Moyr (n) = c4 n ln n
p(zi , zj ) Expérience : essayons pour n = 100000 et estimons n = 300000
i=1 j=i+1
T s (100000) T r (100000)
c3 = c4 =
zi et zj sont comparés ssi un des deux est le premier pivot parmi zi , zi+1 , . . . , zj 1000002 100000 ln 100000
I sinon, le pivot zk sépare zi < zk et zj > zk ! et donc (pour T s (100000) = 1.7 et T r (100000) = .006) :
Donc p(zi , zj ) = 2/(j − i + 1) (les choix de pivot sont équiprobables) T s (100000)
T s (300000) = × 3000002 ' 15.3
n−1 X
n n−1 X
n−i n−1 Xn 1000002
X 2 X 2 X 1 T r (100000)
= ≤2 ' 2nln n T r (300000) = × 300000 ln 300000 ' 0.019
i=1 j=i+1
j −i +1 i=1 j=1
j + 1 i=1 j=1
j 100000 ln 100000

Complexité Algorithmique
Vision pessimiste : la complexité d’un algortihme est souvent définie comme sa
performance asymptotique dans le pire cas
Que signifie dans le pire des cas ?
I Parmi toutes les données x de taille n, on ne considère que celle qui maximise CoûtA (x)
Que signifie asymptotique ?
I comportement de l’algorithme pour des données de taille n arbitrairement grande
Analyse Asymptotique I pourquoi ?
Soit deux algorithmes de complexités

f1 (n) et f2 (n)
Quel algorithme préférez-vous ?
La courbe verte semble correspondre à
un algorithme plus efficace...
... mais seulement pour de très petites
valeurs !
Analyse Asymptotique 27 / 99 Analyse Asymptotique 28 / 99
Ordre de grandeur : motivation Notation O : définition
O(g (n)) est l’ensemble de fonctions f (n) telles que :

Les calculs à effectuer pour évaluer le temps d’exécution d’un algorithme peuvent
parfois être longs et pénibles ; ∃n0 ∈ N, ∃c ∈ R, ∀n ≥ n0 : f (n) ≤ c × g (n)
De plus, le degré de précision qu’ils requièrent est souvent inutile ;

Borne supérieure : f (n) ∈ O(g (n)) s’il existe une constante c, et un
I n log n + 5n → 5n va devenir “négligeable” (n >> 1000)
I différence entre un algorithme en 10n3 et 9n3 : effacé par une accélération de 10
de la
seuil à partir duquel f (n) est inférieure à g (n), à un facteur
9
machine c près ;
Exemple : f (n) ∈ O(g (n))
On aura donc recours à une approximation de ce temps de calcul, représentée par les
notations O, Ω et Θ
Hypothèse simplificatrice
On ne s’intéresse qu’aux fonctions asymptotiquement positives
(positives pour tout n ≥ n0 )

Notation O : preuve Notation O : exemple
O(g (n)) est l’ensemble de fonctions f (n) telles que : O(g (n)) est l’ensemble de fonctions f (n) telles que :
∃n0 ∈ N, ∃c ∈ R, ∀n ≥ n0 : f (n) ≤ c × g (n) ∃n0 ∈ N, ∃c ∈ R, ∀n ≥ n0 : f (n) ≤ c × g (n)
Prouver que f (n) ∈ O(g (n)) : jeux contre un perfide adversaire ∀ Jeux : prouver que la fonction f2 (n) = 6n2 + 2n − 8 est en O(n2 ) :
Tour du joueur ∃ choisit c et n0 Tour du joueur ∃ choisit c = 6 et n0 = 0
Tour du joueur ∀ choisit n ≥ n0 Tour du joueur ∀ choisit n = 5
Arbitre détermine le gagnant : f (n) ≤ cg (n) Arbitre 6 × 52 + 2 × 5 − 8 > 6 × 52
Notation O : exemple Focus sur O
O(g (n)) est l’ensemble de fonctions f (n) telles que :

O(g (n)) est l’ensemble de fonctions f (n) telles que : ∃n0 ∈ N, ∃c ∈ R+∗ , ∀n ≥ n0 : f (n) ≤ c × g (n)
∃n0 ∈ N, ∃c ∈ R, ∀n ≥ n0 : f (n) ≤ c × g (n)
c × g (n)
f ∈ O(g )
Jeux : prouver que la fonction f2 (n) = 6n2 + 2n − 8 est en O(n2 ) :
Tour du joueur ∃ choisit c = 7 et n0 = 0

f 0 ∈ O(g )
Tour du joueur ∀ choisit ?
n0 n
Arbitre n2 − 2n + 8 = 0 n’a pas de solution
Exercice : 2n2 est-il en O(n2 ) ? Pareil pour 2n.

Notation Ω : définition Notation Θ : définition
Ω(g (n)) est l’ensemble de fonctions f (n) telles que :
∃n0 ∈ N, ∃c ∈ R+∗ , ∀n ≥ n0 : f (n)≥c × g (n)

Θ(g (n)) est l’ensemble de fonctions f (n) telles que :
Borne inférieure : f (n) ∈ Ω(g (n)) s’il existe un seuil à partir duquel f (n)
∃c1 , c2 ∈ R+∗ , ∃n0 ∈ N, ∀n > n0 , c1 × g (n) ≤ f (n) ≤ c2 × g (n)
est supérieure à g (n), à une constante multiplicative près ;
Exemple : g (n) ∈ Ω(f (n))
Borne supérieure et inférieure : Θ(g (n)) = Ω(g (n)) ∩ O(g (n)) ; f (n)
est en Θ(g (n)) si elle est prise en sandwich entre c1 g (n) et
c2 g (n) ;
Focus sur Θ Notation asymptotique d’une fonction

f (n) est en Θ(g (n)) si :
Quelle est la borne asymptotique de f (n) ?
∃c1 , c2 ∈ R+∗ , ∃n0 ∈ N, ∀n > n0 , c1 × g (n) ≤ f (n) ≤ c2 × g (n) Notation asymptotique (de l’expression fermée) d’une fonction
Les mêmes simplifications pour O, Ω et Θ :
c2 × g (n) on ne retient que les termes dominants
f ∈ Θ(g ) on supprime les constantes multiplicatives
c1 × g (n)
Exemple
Soit g (n) = 4n3 − 5n2 + 2n + 3 ;
1 on ne retient que le terme de plus haut degré : 4n3 (pour n assez grand le terme en
n3 “domine” les autres, en choisissant bien c1 , c2 , on peut avoir c1 n3 ≤ g (n) ≤ c2 n3 )
n 2 on supprime les constantes multiplicatives : n3 (on peut la choisir !)
k
et on a donc g (n) ∈ Θ(n3 )
Exercice : 2n2 est-il en Θ(n2 ) ? Pareil pour 2n.
Relation des principaux ordres de grandeur Ordres de grandeurs : exemples
2n n2 Une instruction de base est de l’ordre de la µs.

T./C. log n n n log n n2 2n
1000µs
10 3µs 10µs 30µs 100µs
n log n
1014 siècles
100 7µs 100µs 700µs 1/100s
astronomique
1000 10µs 1000µs 1/100s 1s
n astronomique
10000 14µs 1/100s 1/7s 1.7mn
log n
n
astronomique
100000 17µs 1/10s 2s 2.8h
Indépendant de la taille de la donnée : O(1)/Θ(1)
Règles de calculs : combinaisons des complexités Règles de calculs : combinaison des complexité
Les instructions de base prennent un temps constant, noté O(1) ;
On additionne les complexités d’opérations en séquence : Dans les boucles, on multiplie la complexité du corps de la boucle par le nombre
d’itérations ;
O(f (n)) + O(g (n)) = O(f (n) + g (n))
Même chose pour les branchements conditionnels : Calcul de la complexité d’une boucle while :
max(O(f (n)), O(g (n))) = O(f (n)) + O(g (n))
Exemple
Exemple
 en supposant qu’on a O(h(n)) itérations
si <condition> alors O(g (n)) 
tant que <condition> faire

#instructions (1); O(f1 (n))
 O(g (n))
= O(h(n) × (g (n) + f (n)))

= O(g (n) + f1 (n) + f2 (n)) #instructions ; O(f (n))
sinon 

#instructions (2); O(f2 (n))


Règles de calculs : combinaison des complexité Calcul de la complexité asymptotique d’un
algorithme
Dans les boucles, on multiplie la complexité du corps de la boucle par le nombre

d’itérations ;
Pour calculer la complexité d’un algorithme :
Calcul de la complexité d’une boucle for : 1 on calcule la complexité de chaque “partie” de l’algorithme ;
2 on combine ces complexités conformément aux règles qu’on vient de voir ;

Exemple
3 on simplifie le résultat grâce aux règles de simplifications qu’on a vues ;
F élimination des constantes, et
pour i allant de a à b faire

F conservation du (des) termes dominants
#instructions ; = O((b − a + 1) × f (n))
O(f (n))
Exemple : calcul de la factorielle de n ∈ N Exemple : Tri à bulles

La méthode de “comptage” n’est pas toujours applicable directement
Reprenons le calcul de la factorielle, qui nécessitait 3n opérations :
Algorithme : TriBulles(T )
Données : un tableau T
Algorithme : Factorielle(n) Résultat : le tableau T trié
nombre coût
Données : un entier n 1 n ← |T |; nombre coût
2 do
Résultat : un entier valant n!
3 m ← 0;
1 fact, i : entier; 4 pour i allant de 2 à n faire
2 début 5 si T [i − 1] > T [i] alors itérations : Θ(|T |)× Θ(1)
3 fact ← 2; initialisation : Θ(1)× Θ(1) 6 échanger(T [i − 1], T [i]); itération : ?× Θ(1)
4 pour i allant de 3 à n faire 7 m ← i;
itérations : Θ(n)× Θ(1)
5 fact ← fact ∗ i; mult. + affect. : Θ(n)× Θ(1) 8 n ← m;
6 retourner fact; retour fonction : Θ(1)× Θ(1) 9 while n > 0;
Séries arithmétiques
Nombre total d’opérations :
n
X 1
k = 1 + 2 + 3 + ··· + n = n(n + 1) ∈ Θ(n2 )
Θ(1) + Θ(n) ∗ Θ(1) + Θ(n) ∗ Θ(1) + Θ(1) = Θ(n) k=1
2
Analyse Asymptotique 46 / 99 Nombre total d’opérations : Θ(|T |2 ) Analyse Asymptotique 47 / 99

Ensembles (notations)
Soit U un ensemble, et e un élément.
On note e ∈ E “e est un élément de E ”

Représentation des Données
On note |E | le nombre d’éléments de E (sa cardinalité)
Pour U, V deux ensembles, on note V ⊆ U “tout élément de V est un élément de U”

(V est une partie U)
On note 2U l’ensemble des parties de U (parfois P(U))
Représentation des Données 48 / 99 Représentation des Données 49 / 99
Mots mémoire et représentation des données Langages et codes
Alphabet
Ensemble fini de caractères : Langage
Σbin = {0, 1} l’alphabet binaire
Un langage sur l’alphabet Σ est un ensemble de mots sur Σ. L’ensemble de
Σlatin = {a, b, c, . . . , z} l’alphabet latin tous les mots sur Σ est noté Σ∗ .
Σbio = {A, T , G , C } l’alphabet génétique le mot vide : ∈ Σ∗ ;
L’ensemble des caractères ASCII les caractères : si w ∈ Σ alors w ∈ Σ∗ ;
les mots obtenus par l’opération de concatenation “·” de deux mots : si v ∈ Σ∗ et
Mot w ∈ Σ∗ alors v · w ∈ Σ∗
Un mot w sur l’alphabet Σ est une suite finie w1 w2 . . . wn de lettres de Σ.
L’entier n est appelé la longueur du mot w . Il est noté |w |. Code
“0110101” est un mot de longueur 6 sur Σbin Fonction injective f : Σ 7→ Σ0
“maux” est un mot de longueur 4 sur Σlatin Code binaire f : Σ 7→ Σ∗bin
“vuwboj” est un mot de longueur 6 sur Σlatin
“%&))+dfW4” est un mot de longueur 9 sur l’alphabet ASCII

Exemple : représentation d’un entier (borné) Exemple : représentation d’une partie d’un
ensemble (fixé)
0 1 0 0 1 0 1 1
0 1 0 0 1 0 1 1
27 26 25 24 23 22 21 20 e8 e7 e6 e5 e4 e3 e2 e1
Représenter les entiers entre 0 et 255

Représenter une partie de U = {e1 , e2 , e3 , e4 , e5 , e6 , e7 , e8 }
Chaque bit repésente un terme de la somme Chaque bit repésente un élément de U, V ⊆ U est représenté par un mot w qui code
sa fonction caractéristique :
7
X
x= bi 2i χV : U 7→ {0, 1}
i=0

1 si ei ∈ V
ei 7→
0 si ei ∈
6 V
Pour x = 75 : 1 × 26 + 1 × 23 + 1 × 21 + 1 × 20
f ({e7 , e4 , e2 , e1 }) 7→ w = 01001011
Codage binaire La taille de la donnée
Taille de la donnée |x|

2 ×2 ×2 ×2 ×2 ×2 ×2 ×2
Espace mémoire nécessaire pour coder un élément du langage Σ dans le langage Σ∗bin
0/1 0/1 0/1 0/1 0/1 0/1 0/1 0/1 Valeur maximum de |f (x)| pour tout f : Σ 7→ Σ∗bin et tout x ∈ Σ
7 6 5 4 3 2 1 0
Code de longueur fixe (n) : langage Σnbin = {w | w ∈ Σ∗bin , |w | = n}
Combien de mots de n caractères dans Σ∗bin ? Taille n, nombre de mots 2n , permet de coder des langages de 2n mots ou moins
Donc un langage contenant N mots requiert un code de longueur log2 (N)

2n mots
Quantité d’information
Il n’est pas possible de coder un langage contenant plus de 28 = 256 mots sur 8 bits La Quantité d’information transportée par un message d’un mot dans un
langage de cardinalité N est log2 (N).

Codage de la donnée Exemple : codage d’un entier (Σ = N)
Si m est une constante (32, 64, . . .) la taille d’un code de longueur fixe n est O(1)
Bonne nouvelle : l’alphabet n’est pas important
0 0 0 0 0 0 0 1 0 0 1 0 1 1
I Ex : on peut coder les lettres de l’alphabet latin sur dlog2 (26)e = 5 bits (O(1) bits) | {z }
I Un mot de Σ∗latin de longueur n se code sur au plus 5n bits : la taille du code ne change N◦ de 0 = N◦ de bits =7 26 25 24 23 22 21 20
pas (de façon asymptotique)
Mauvaise nouvelle : les données ont le plus souvent un nombre de valeurs possibles
infini (entier, liste de caractères, etc.) Pour représenter [0, x] (x ∈ N), il faut Ω(log2 (x)) bits
I Quel que soit n, il existe x ∈ N tel que x > 2n et donc le langage N n’a pas de code
binaire de longueur fixe
Supprimer les 0 non-significatifs, rajouter autant de 0 que de bits “utiles” en préfixe
Code de longueur variable

On donne sa taille en fonction d’un paramètre de la donnée, ex : Code en O(log2 (x)) pour le préfixe + O(log2 (x)) pour le suffixe
(valeur) f : N 7→ Σ∗bin tel que si x ≤ n alors |f (x)| ∈ O(log2 (n))
(longueur) Liste de caractères : si l a au plus n éléments alors |f (l)| ∈ O(n)
Exemple : codage d’une liste d’int (sur 32 bits) Résumé
Espace pour coder une donnée x pouvant prendre N valeurs

struct{
Borne inférieure : au moins log2 N bits (|x| ∈ Ω(log2 N))
int valeur; // O(1)
Borne supérieure : taille d’un code binaire
struct Element* suivant; // O(1)
} Element;
Dans un langage borné (type primitif char, int, float,...), code de longueur fixe (8,
32, 64 bits) : Θ(1)
Code en O(n) bits
Dans un langage contenant un nombre infini d’éléments, on exprime la complexité
dans le(s) paramètre(s) adéquat(s)
(232 )n listes possibles de n int
I |x| ∈ Θ(n) pour une liste x de n caractères
I |x| ∈ Θ(n) pour un ensemble x d’éléments parmis n

32 n
Quantité d’information : log2 (2 ) = 32n, donc tout code est en Ω(n) I |x| ∈ Θ(log2 n) pour un entier x inférieur ou égal à n

Complexité en fonction de la taille de la donnée
L’algorithme A est en Θ(f (x)) pour une donnée x

La taille |x| de la donnée est en Θ(g (x))
Alors la complexité de A est en Θ(f (g −1 (x)))
Exemple
Algorithme : Carré(x) Combinatoire et Dénombrement

Données : un entier x
Résultat : un entier valant x 2 Complexité : Θ(x 2 )
r : entier;
début Taille de la donnée |x| = Θ(log x)
r ← 0;
pour i allant de 1 à x faire
pour j allant de 1 à x faire Autrement dit, x = Θ(2|x| )
r ← r + 1;
retourner r ; Donc complexité en Θ(22|x| ) (exponentielle !)
Représentation des Données 60 / 99 Combinatoire et Dénombrement 61 / 99
Combinatoire Principes de base
Principe additif
Les choix mutuellement exclusifs se combinent par addition.
Dénombrement
Ex : combien de choix possibles de plats principal si on a 3 types de viande, 2 poisson
“Compter le nombre d’éléments d’un ensemble” et 3 plats végétariens ?
3 + 2 + 3 = 8 possibilités
Calculer la taille d’une donnée (compter le nombre de valeurs possibles)
Principe multiplicatif
Calculer la complexité en temps d’un algorithme (compter le nombre d’opérations) Les choix indépendents se combinent par multiplication.
Ex : combien de menus possibles s’il y a 3 entrées, 4 plats, et 4 desserts ?
3 × 4 × 4 = 48 possibilités
Combinatoire et Dénombrement 62 / 99 Combinatoire et Dénombrement 63 / 99

Principes de base Principe d’exclusion-inclusion, exemple
Quel est le nombre d’entiers naturels inférieurs ou égaux à n qui sont
Principe d’exclusion-inclusion divisibles par 2, 3 ou 5 ?
La cardinalité de l’union de deux ensembles est égale à la somme des Il y a bn/2c entiers divisibles par 2
cardinalités des ensemble moins la cardinalité de l’intersection Il y a bn/3c entiers divisibles par 3
Il y a bn/5c entiers divisibles par 5
|A ∪ B| = |A| + |B| − |A ∩ B|
Il y a bn/6c entiers divisibles par 2 et 3
En général, soit C = {Ei | 1 ≤ i ≤ n} une collection d’ensembles. Alors : Il y a bn/10c entiers divisibles par 2 et 5
n n i Il y a bn/15c entiers divisibles par 3 et 5

[ X X \
i−1
Ei = −1 Ej k Il y a bn/30c entiers divisibles par 2, 3 et 5
i=1 i=1 1≤j1 <...<ji ≤n k=1
il y en a donc :
Avec trois ensembles : bn/2c + bn/3c + bn/5c − bn/6c − bn/10c − bn/15c + bn/30c ' 22n/30
|A∪B ∪C | = |A|+|B|+|C |−|A∩B|−|A∩C |−|B ∩C |+|A∩B ∩C |
Principes de base Permutations simples
Principe des tiroirs

Si m objets sont rangés dans n tiroirs, alors un tiroir en contient au moins d mn e. Une permutation est un ordre sur un ensemble
Si m > n objets sont rangés dans n tiroirs, alors un tiroir en contient au moins 2 Nombre de permutations
Nombre de permutations de n éléments :
Il y a deux londoniens avec exactement le même nombre de cheveux
Pn = n!
I Il n’y a pas plus d’un million de cheveux sur un crâne, donc pas plus d’un million de
nombres de cheveux distincts
n positions pour le premier éléments, n − 1 pour le deuxièmes, etc.
I Il y a plus d’un million de londoniens 24 “club sandwiches” (lard, laitue, tomate, mayonnaise)
8.065 · 1067 mélanges d’un jeu de 52 cartes
I m londoniens à répartir parmi n chevelures possibles ⇒ au moins deux londoniens avec la
même chevelure

Permutations avec répétitions Arrangements simples
Ordre sur un sac (ensemble avec des éléments répétés)
Soit un sac de cardinalité n avec k ≤ n éléments distincts où ni et le nombre de

répétitions de l’élément i Un arrangement de p éléments parmi n est un ordre sur une partie de cardinalité p
d’un ensemble
Nombre de permutations
Nombre d’arrangements
Nombre de permutations de k éléments avec répétitions n1 , n2 , . . . , nk :
Nombre d’arrangements de p parmi n éléments :
n!
P¯n (n1 , n2 , . . . , nk ) = Qk n!
Anp =
i=1 ni ! (n − p)!
Pour chaque élément i y a ni ! permutations symétriques par réarrangement des n positions pour le 1er éléments, n − 1 pour le 2èmes, . . ., n + 1 − p pour le pème.
répétitions de i
360 “club sandwiches” si on rajoute les deux tranches de pain (= 6!/2!)
Combinaisons simples Borne inférieure pour les algorithmes de tri
Tri
donnée : une table d’éléments comparables
but : donner une liste triée de ces éléments
Une combinaison est une partie de cardinalité p d’un ensemble
Considérons les algorithmes de tri qui ne peuvent pas “lire” ces éléments, seulement
Nombre de combinaisons les comparer (e.g. un tableau de pointeurs vers une classe d’objets comparables).
Nombre de combinaisons de p parmi n éléments : Lors de son execution, cet algorithme va comparer k paires d’éléments (x, y ), le
résultat peut être 0 (x < y ) ou 1 (x ≥ y )
n!
Cnk =
(n − p)!p! On peut considérer que la donnée de l’algorithme est une table de longueur k avec les
résultats des comparaisons :
Une combinaison de p éléments peut être arrangée de p! façon, donc Cpn = Anp /p! x = [0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1]
| {z }
k

Borne inférieure pour les algorithmes de tri Borne inférieure pour les algorithmes de tri
Algorithme deterministe, donc deux tables identiques donnent la même exécution
[0, 0, 1, 0, 1, 1, 1, 1, . . .] (e1 , e2 , e3 , e4 , . . .) Théorème

[0, 0, 1, 0, 1, 1, 1, 1, . . .] (e1 , e2 , e4 , e3 , . . .)
[0, 1, 0, 0, 1, 0, 0, 1, . . .] (e1 , e3 , e2 , e4 , . . .) Tout algorithme de tri par comparaison est en Ω(n log n)
2k [1, 0, 0, 0, 0, 1, 1, 1, . . .] (e1 , e3 , e4 , e2 , . . .) n!
[0, 1, 1, 0, 1, 1, 0, 0, . . .] (e1 , e4 , e2 , e3 , . . .)
[1, 0, 1, 0, 0, 1, 1, 0, . . .] (e1 , e4 , e3 , e2 , . . .)
[0, 0, 1, 0, 1,.. 1, 1, 1, . . .] (e1 , e2 , e..3 , e4 , . . .) Attention, il existe des algorithmes de tri en O(n)
. .
I Mais ces algorithmes font des hypothèses sur les éléments à trier
Au plus k comparaisons, donc au plus 2k données/exécutions distinctes
Chacune des n! permutations de la donnée doit correspondre à une exécution distincte
Dans le cas général d’éléments comparables sans propriété particulière : impossible de
principe des tiroirs les trier avec une complexité dans le pire des cas inférieure à Ω(n log n)
n n
2k ≥ n! → 2k ≥ (n/2)n/2 → k ≥ log → k ∈ Ω(n log n)
2 2
Comparer les tailles de deux ensembles infinis La Méthode de Diagonalisation
La taille (ou cardinalité) |E | d’un ensemble E est le nombre d’éléments de cet ensemble
Georg Cantor
{1, 2, 3} et {A, B, C , D} ?
Est-ce qu’il y a deux fois plus d’entiers que d’entiers pairs ?
L’ensemble des atomes qui constituent un morceau de craie et l’ensemble des protons
qui appartiennent au même morceau de craie ? Ou est-ce que deux ensembles infinis ont la même taille
(infinie) ?
Les entiers naturels et les entiers naturels pairs ?

La réponse de Cantor est “non” pour les deux questions, il
Les entiers naturels et les réels ? n’y pas plus d’entiers que d’entiers pairs mais il existe
differentes variétés d’infinis !

La Méthode de Diagonalisation La Méthode de Diagonalisation
Les entiers naturels et les entiers naturels pairs ?

Les entiers naturels (N) et les nombres rationels (Q) ?
Quelle définition donner à l’(in)égalité entre deux nombres infinis ?
I l’inclusion ne permet pas de comparer tous les ensembles On peut associer chaque élément de N à exactement un élement de N × N
.. .. .. .. .. ·
. . . . . ··
Comparaison Bijection f : N × N 7→ N
Deux ensemble E1 , E2 sont équipotent si et seulement s’il existe une 0, 4 1, 4 2, 4 3, 4 4, 4 ...

bijection f : E1 7→ E2 14 f (x, y ) = 12 (x + y + 1)(x + y ) + y
0, 3 1, 3 2, 3 3, 3 4, 3 ...
On peut associer chaque élément de E1 à exactement un élement de E2 9 13
1
... f (3, 1) = × 5 × 4 + 1 = 11
0 ←→ 0 0, 2 1, 2 2, 2 15 3, 2 4, 2 2
1 ←→ 2 5 8 10 12
2 ←→ 4 0, 1 1, 1 6 2, 1 3, 1 4, 1 ...
f (n) = 2n, f −1 (n) = n f est inversible
3 ←→ 6 2
.. .. 2 3 4 7 11
. . 0, 0 1, 0 2, 0 3, 0 4, 0 ...
n ←→ 2n 1
Y’a-t’il plus d’ensembles d’entiers que d’entiers ? Ensembles (in)dénombrables
Les entiers naturels (N) et l’ensemble des parties de N (2N ) ?
On suppose qu’il existe une bijection f : 2N 7→ N ; f (Tx ) 7→ x

I Matrice Mi,j binaire telle que Mi,j est 1 ssi l’élément j est dans la ième partie de N.
Un ensemble est dénombrable si et seulement si il est équipotent à N
T∗ 1 1 0 0 1 0 ... ?
.. Soit T ∗ la partie de N qui
·
. ·· contient i ssi i 6∈ Ti
Ti 0 0 1 ... ... 1
I Ex : N+ , Z, Q sont dénombrables
Si f est une bijection, alors
.. 0 .. f (T ∗ ) = j ∈ N
. 1 .
Est-ce que j appartient à T ∗ ?
T2 0 1 1 .. I Ex : 2N , R ne sont pas dénombrables
T1 1 0 0 . Contradiction ⇒ l’hypothèse
(“∃ une bijection f : 2N 7→ N”)
T0 0 0 0
est fausse !
0 1 2 ... ... i ... j

Graphes (notations)
Graphe G = (V , E )
Un ensemble d’objets dont certains sont liés deux à deux.
Un graphe G = (V , E ) est défini par un ensemble de sommets V et un
ensemble d’arêtes E . Une arête e ∈ E est une paire de sommets qui peut
Quelques Notions de Graphe être ordonnée (on parle de graphe orienté) ou pas (graphe non-orienté).
V E
{1, 2} 1 1
1 {1, 3}
2 {1, 4} 2 3 2 3
Ex : 3 {2, 5}
4 4
4 {3, 6}
5 {4, 5}
6 {4, 6} 5 6 5 6
{5, 6}
Quelques Notions de Graphe 80 / 99 Quelques Notions de Graphe 81 / 99
Isomorphismes Chaînes et Chemins
4 1 1
1 4
1 3
2 3 2 3
2 3 = 1 3 =
4 4
4 6
2 5
5 6 5 6
5 6 2 5
6
La façon dont le graphe est déssiné n’a pas d’importance Chaînes et Chemins
Le nom des sommets n’a pas d’importance Une chaîne (resp. un chemin) de x0 vers xk dans un graphe (orienté)
G = (V , E ) est est une liste ordonnée de sommets x0 , . . . , xk telle que pour
isomorphisme tout 1 ≤ i ≤ k {xi−1 , xi } ∈ E (resp. (xi−1 , xi ) ∈ E ).
G = (V , E ) est isomorphe à G 0 = (V 0 , E 0 ) s’il existe une bijection Élémentaire si tout les sommets sont distincts (sauf x0 et xk ).
f : V 7→ V 0 telle que (u, v ) ∈ E ⇐⇒ (f (u), f (v )) ∈ V 0

Cycles et Circuits Les ponts de Koenigsberg
1 1 Est il possible de visiter Koenigsberg en traversant chaque pont exactement une fois ?
2 3 2 3 C
4 4
5 6 5 6 A D
Cycles et Circuits
B
Un cycle (resp. circuit) dans un graphe (orienté) G = (V , E ) est une
chaîne (resp. un chemin) d’un sommet x vers lui-même.
Graphe Eulerien
Connexité Un graphe G = (V , E ) est dit Eulerien s’il contient un cycle x0 , x1 , . . . , x|E |
Un graphe est (bi)connexe si toute paire de sommets appartient à une passant une et une seule fois par chaque arête, i.e., x0 = x|E | et
chaîne (un cycle) {{xi−1 , xi } 1 ≤ i ≤ |E |} = E .
Arbres Tas Binaire

Invariants : arbre binaire complet ; sommet parent ≤ fils
Arbre
Un graphe est un arbre si et seulement si il est acyclique et connexe. 1 67
2
3
Arbre enraciné 2 67
3
5 3 6
I Orientation racine → feuilles
Arbre binaire : au plus deux fils

4 8 5 67
3
5 6 50 7 38
Complet : si profondeur max n
alors 2n−1 sommets de
profondeur n − 1 8 12 9 95 67
3
Profondeur d’un arbre complet Ajout : la position libre la plus à gauche possible sur le dernier niveau
La longueur maximale d’un chemin vers une feuille d’un arbre binaire I Percolation échange avec le parent jusqu’à ce que l’invariant soit rétabli O(log n)
complet est dlog2 ne(∈ O(log n)) Extraction du minimum : la racine, qu’on remplace par le “dernier” sommet
I Percolation échange avec le fils minimum jusqu’à ce que l’invariant soit rétabli O(log n)

Tri par tas
Donnée : une liste L d’éléments comparables

Pour chaque x ∈ L :
Ajouter x au tas H
Tant que H n’est pas vide : Algorithmes Récursifs
Extraire le minimum de H et l’afficher
n ajouts en O(log n) Tri par tas est optimal !

n extractions en O(log n) O(n log n) dans le pire des cas
Complexité du tri par tas : O(n log n) Algorithmes de tri en Ω(n log n)
Quelques Notions de Graphe 88 / 99 Algorithmes Récursifs 89 / 99
Récurrences Illustration du Tri Fusion
Stratégie “diviser pour régner” Algorithme : Fusion (T1 ,T2 )

Données : deux tableaux T1 et T2
Résultat : un tableau T trié contenant les
Algorithme : TriFusion (T ) éléments de T1 et de T2
Données : un tableau T T : tableau de taille T1 + T2 ;
Résultat : le tableau T trié i, j, k ← 1;
mil : entier; début
début tant que k < |T | faire
si |T | ≤ 1 alors si i = |T1 | ou T1 [i] > T2 [j] alors
retourner T ; T [k] ← T2 [j];
sinon j ← j + 1;
|T |+1 sinon
mil ← b 2 c;
Tl ← TriFusion(T [:mil]); T [k] ← T1 [i];
Tr ← TriFusion(T [mil:]); i ← i + 1;
retourner Fusion(Tl , Tr ); k ← k + 1;
Algorithmes Récursifs 90 / 99 Algorithmes Récursifs 91 / 99

Récurrences Méthode par substitution
Il faut avoir une intuition sur la forme de la solution (ici : O(n log n))
Temps d’exécution T dans le pire des cas du tri fusion pour trier un tableau de n
entiers
On veut montrer que T (n) = 2T (bn/2c) + Θ(n) ∈ O(n log n)
( On montre par récurrence qu’il existe f (n) t.q. ∀n T (n) ≤ f (n)

Θ(1) si n = 1
T (n) = I On va en déduire a posteriori que T (n) ∈ O(f (n))
2T (n/2) + Θ(n) si n > 1
Complexité du tri fusion : T (n) = Θ(n log n) Attention !

L’hypothèse de récurrence est T (n) ≤ f (n), et non T (n) ∈ O(f (n))
Comment passer de l’un à l’autre ?
L’argument inductif “pour tout x < n, T (x) ∈ O(f (x))” ne veut pas dire grand chose
I Méthode par substitution
puisque la notation O est définie pour n arbitrairement grand : on remplace tous les
I Méthode générale (théorème maître)
termes en O, Ω, Θ par une fonction élément de l’ensemble
Méthode par substitution (condition aux limites) Méthode par substitution (condition aux limites)
T (n) = 2T (bn/2c) + n ≤ cn log n

T (n) = 2T (bn/2c) + n ≤ cn log n
On vérifie que la formule tient pour T (2) et T (3)
T (2) = 2T (b2/2c) + 2
Il faut montrer que la formule est vraie pour les conditions limites de la récurrence
pour des données de petite taille, i.e. n = 1
T (2) = 2T (1) + 2
Problème : c’est faux pour n = 1 car c × 1 × log 1 = 0 < T (1) = 1 ;
T (2) = 2 ∗ 1 + 2 = 4 ≤ 2c log 2 = 2c
Mais on cherche à montrer la complexité pour des données de grande taille : n ≥ n0
et on a le choix pour n0 =⇒ vérifier pour T (2) (et T (3)) T (2) = 4 ≤ 2c
On peut aussi borner par f (n) = cn log n + b puisque cn log n + b ∈ O(n log n)
c≥2
I Ou même f (n) = cn log n + an + b
On fait la même chose pour T (3)...
... et on obtient que c doit être ≥ 2.
Méthode par substitution (Récurrence) Diviser pour régner
T (n) = 2T (bn/2c) + n ≤ cn log n Exemple

Algorithme : TriFusion (T )
On suppose maintenant que T (x) ≤ cx log x est vrai pour tout 2 ≤ x ≤ n − 1 ; et on Données : un tableau T
Résultat : le tableau T trié
vérifie que c’est aussi le cas pour x = n (
mil : entier;
début
Θ(1) si n = 1
T (bn/2c) ≤ cbn/2c logbn/2c T (n) = 1d
si |T | ≤ 1 alors 2aT (n/2b) + Θ(n ) si n > 1
retourner T ;
On substitue dans l’expression sinon
|T |+1
mil ← b 2 c; Trifusion : a = 2, b = 2, d = 1
T (n) = 2T (bn/2c) + n
≤ 2cb 2n c log(b 2n c) + n Tl ← TriFusion(T [:mil]); Recherche Binaire : a = 1, b = 2, d = 0
Tr ← TriFusion(T [mil:]);
≤ cn log(n/2) + n
retourner Fusion(Tl , Tr );
= cn log n − cn log 2 + n
= cn log n − cn + n
≤ cn log n
L’algorithme découpe la donnée en a sous-problèmes de taille n/b, les résout
récursivement et rassemble les réponses en Θ(nd )
A condition que c ≥ 1 (on prendra c ≥ 2, à cause de T (2) et T (3))
Théorème maître (général) - version simplifiée Théorème maître (général) - version simplifiée
On ne considère que les récurrences T (n) = aT (n/b) + Θ(nd ) (ou O(nd )) On ne considère que les récurrences T (n) = aT (n/b) + Θ(nd ) (ou O(nd ))
avec a ≥ 1, b > 1, d ≥ 0 avec a ≥ 1, b > 1, d ≥ 0
1 Si d > logb a, T (n) = Θ(nd ) complexité dominée par le coût de fusion 1 Si d > logb a, T (n) = Θ(nd ) complexité dominée par le coût de fusion
2 Si d < logb a, T (n) = Θ(nlogb a ) complexité dominée par le coût du sous-problème 2 Si d < logb a, T (n) = Θ(nlogb a ) complexité dominée par le coût du sous-problème
3 Si d = logb a, T (n) = Θ(nd log n) pas de domination 3 Si d = logb a, T (n) = Θ(nd log n) pas de domination
Tri fusion : ( Recherche binaire : (

Θ(1) si n = 1 Θ(1) si n = 1
T (n) = T (n) =
2T (n/2) + Θ(n) si n > 1 T (n/2) + Θ(1) si n > 1
a = 2, b = 2, d = 1, log2 2 = 1 = d a = 1, b = 2, d = 0, log2 1 = 0 = d
On est donc dans le 3ème cas et la complexité en Θ(n log n) On est donc dans le cas 3 et la complexité en Θ(log n)

Handout1 7s

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

Handout1 7s

Transféré par

Droits d'auteur :

Formats disponibles

Plan

2 Complexité des Algorithmes

Emmanuel Hebrard 7 Algorithmes Récursifs

Question d’un entretien d’embauche chez Google

Les trois problèmes ci-dessous sont-ils faciles ? Difficiles ?

Savoir développer des algorithmes efficaces

Trois problèmes de pavage Trois problèmes de pavage

Problème 1 : (Tetris) Problème 1 : (Tetris)

Problème du Voyageur de Commerce

Problème, Donnée & Algorithme

Définition : Problème ' fonction sur les entiers

Algorithme : méthode pour résoudre un problème

Complexité des Algorithmes 9 / 99 Complexité des Algorithmes 10 / 99

On veut être capable de : Le temps d’exécution

Complexité des Algorithmes 11 / 99 Complexité des Algorithmes 12 / 99

Nombre d’opérations élémentaires (I) Exemple

L’algorithme suivant calcule n! = n × (n − 1) × (n − 2) × · · · × 2 × 1 (avec 0! = 1).

Opération élémentaire nombre coût

Complexité des Algorithmes 13 / 99 Complexité des Algorithmes 14 / 99

L’algorithme suivant trie un tableau T de n éléments.

Complexité des Algorithmes 15 / 99 Complexité des Algorithmes 16 / 99

Exemple : TriRapide Nombre d’opérations élémentaires (II)

Complexité des Algorithmes 17 / 99 Complexité des Algorithmes 18 / 99

Soit CoûtA (x) la complexité de l’algorithme A sur la donnée x de taille n.

InfA (n) = min{CoûtA (x) | x de taille n} Le nombre de comparaisons dépend

Complexité des Algorithmes 19 / 99 Complexité des Algorithmes 20 / 99

Complexité en moyenne (Recherche) Complexité en moyenne (TriSélection)

Le temps de calcul T (n) de TriSélection pour n élément est tel que :

Algorithme : TriRapide Algorithme : TriRapide

Complexité des Algorithmes 23 / 99 Complexité des Algorithmes 24 / 99

Complexité en moyenne (TriRapide) Résumons

Complexité des Algorithmes 25 / 99 Complexité des Algorithmes 26 / 99

Soit deux algorithmes de complexités

Analyse Asymptotique 27 / 99 Analyse Asymptotique 28 / 99

Ordre de grandeur : motivation Notation O : définition

O(g (n)) est l’ensemble de fonctions f (n) telles que :

De plus, le degré de précision qu’ils requièrent est souvent inutile ;

Analyse Asymptotique 29 / 99 Analyse Asymptotique 30 / 99

∃n0 ∈ N, ∃c ∈ R, ∀n ≥ n0 : f (n) ≤ c × g (n) ∃n0 ∈ N, ∃c ∈ R, ∀n ≥ n0 : f (n) ≤ c × g (n)

Tour du joueur ∃ choisit c et n0 Tour du joueur ∃ choisit c = 6 et n0 = 0

Tour du joueur ∀ choisit n ≥ n0 Tour du joueur ∀ choisit n = 5

Arbitre détermine le gagnant : f (n) ≤ cg (n) Arbitre 6 × 52 + 2 × 5 − 8 > 6 × 52

Analyse Asymptotique 31 / 99 Analyse Asymptotique 33 / 99

Notation O : exemple Focus sur O

O(g (n)) est l’ensemble de fonctions f (n) telles que :

Tour du joueur ∃ choisit c = 7 et n0 = 0

Exercice : 2n2 est-il en O(n2 ) ? Pareil pour 2n.

Ω(g (n)) est l’ensemble de fonctions f (n) telles que :

∃n0 ∈ N, ∃c ∈ R+∗ , ∀n ≥ n0 : f (n)≥c × g (n)

Analyse Asymptotique 36 / 99 Analyse Asymptotique 37 / 99

Focus sur Θ Notation asymptotique d’une fonction

2n n2 Une instruction de base est de l’ordre de la µs.

Indépendant de la taille de la donnée : O(1)/Θ(1)

Analyse Asymptotique 41 / 99 Analyse Asymptotique 42 / 99

Les instructions de base prennent un temps constant, noté O(1) ;

Analyse Asymptotique 43 / 99 Analyse Asymptotique 44 / 99

Dans les boucles, on multiplie la complexité du corps de la boucle par le nombre

2 on combine ces complexités conformément aux règles qu’on vient de voir ;

Analyse Asymptotique 44 / 99 Analyse Asymptotique 45 / 99

Exemple : calcul de la factorielle de n ∈ N Exemple : Tri à bulles

Analyse Asymptotique 46 / 99 Nombre total d’opérations : Θ(|T |2 ) Analyse Asymptotique 47 / 99

Soit U un ensemble, et e un élément.

On note e ∈ E “e est un élément de E ”