Motivation

Un algorithme est une procdure finie et mcanique de rsolution dun problme.

Exemples : les algorithmes dEuclide, lalgorithme de Dijkstra ...

9. Complexit des algorithmes

Un algorithme doit se terminer sur toutes les donnes possibles du problme et doit fournir une solution correcte dans chaque cas. Pour rsoudre informatiquement un problme donn, on implante donc un algorithme sur un ordinateur. Mais, pour un problme donn, il existe bien souvent plusieurs algorithmes. Y a-t-il un intret choisir ? et si oui comment choisir ? En pratique, il nest mme pas suffisant de dtenir un algorithme. Il existe des problmes pour lesquels on a des algorithmes, mais qui restent comme informatiquement non rsolus . Cest parce que les temps dexcution sont vite exorbitants.
On cherche alors des heuristiques pour abaisser ces temps de calcul.

Complexit
En informatique, le mot complexit recouvre en fait deux ralits : la complexit des algorithmes Cest ltude de lefficacit compare des algorithmes. On mesure ainsi le temps et aussi lespace ncessaire un algorithme pour rsoudre un problme. Cela peut se faire de faon exprimentale ou formelle. la complexit des problmes La complexit des algorithmes a abouti une classification des problmes en fonction des performances des meilleurs algorithmes connus qui les rsolvent. Techniquement, les ordinateurs progressent de jour en jour. Cela ne change rien la classification prcdente. Elle a t conue indpendamment des caractristiques techniques des ordinateurs.

Temps dexcution dun programme

On implante un algorithme dans un langage de haut niveau pour rsoudre un problme donn. Le temps dexcution du programme dpend : des donnes du problme pour cette excution de la qualit du code engendr par le compilateur de la nature et de la rapidit des instructions offertes par lordinateur (facteur 1 1000) de lefficacit de lalgorithme de lencodage des donnes et aussi de la qualit de la programmation !

A priori, on ne peut pas mesurer le temps de calcul sur toutes les entres possibles. Il faut trouver une autre mthode dvaluation. Lide est de saffranchir des considrations subjectives On cherche une grandeur n pour quantifier les entres. On calcule les performances uniquement en fonction de n.
4

(programmeur, matriel,

... ).

Les domaines allis de la complexit et de la preuve de programmes utilisent toutes les notions que nous avons vues jusqu prsent dans ce cours.
3

Modles de calcul
Les machines de Turing (TM) ou les Random Access Machines (RAM) sont des machines abstraites. Elles servent d talon la mesure des complexits en temps et en espace des fonctions dites calculables. Thse de Church*-Turing ** (indpendamment mais les 2 en 1936) Toute fonction effectivement calculable lest par une machine de Turing. Notre optique ici nest videmment pas de prsenter la thorie de la calculabilit mais juste den apprhender les principes les plus simples. Notre approche pragmatique sert comparer des algorithmes rsolvant un mme problme afin destimer rigoureusement lesquels sont les meilleurs.
*
**

TM et RAM
Principe dune machine de Turing une TM est une unit de contrle munie dune tte de lecture/criture positionne sur un ruban qui comporte un nombre infini dnombrable de cases lunit de contrle a un ensemble fini dtats possibles chaque instant, la machine volue en fonction de son tat et de linformation lue sur la case courante : la tte crit sur cette case en effaant le contenu prcdent, se dplace dune case gauche, droite ou bien ne se dplace pas. Une Random Access Machine est compose dune unit de contrle de n registres accs direct doprations lmentaires (LOAD, STORE, READ, WRITE, ADD, JUMP,)

A.Church (1903-1995) : mathmaticien et logicien amricain A.Turing (1912-1954) : mathmaticien britannique

Taille des entres

En premier lieu, il faut valuer la taille des donnes ncessaires lalgorithme. On les appelle les entres ou les instances. La taille n va dpendre du codage de ces entres
Exemple en binaire, il faut log2(n)+1 bits pour coder lentier n.

Reprer les oprations fondamentales

Cest la nature du problme qui fait que certaines oprations deviennent plus fondamentales que dautres dans un algorithme. Leur nombre intervient alors principalement dans ltude de la complexit de lalgorithme. Avec un peu dhabitude, on les repre :

En pratique, on choisit comme taille la ou les dimensions les plus significatives. Quelques exemples, selon que le problme est modlis par : des nombres : ces nombres des polynmes : le degr, le nombre de coefficients 0 des matrices m x n : max (m,n), m.n, m+n des graphes : ordre, taille, produit des deux des arbres : comme les graphes et la hauteur, larit des listes, tableaux, fichiers : nombre de cases, dlments. des mots : leur longueur Le choix de telle ou telle structure de donnes nest pas anodin quant lefficacit dun algorithme.

Recherche dun lment

dans une liste, un tableau, un arbre

comparaisons comparaisons dplacements additions multiplications

Tri
dune liste, dun tableau, dun fichier

Multiplication
de polynmes, de matrices, de grands entiers

Cot des oprations

Dans un ordinateur (un vrai) comme dans une TM ou une RAM, toutes les oprations nont pas le mme cot.
Exemple : multiplication et addition. Cest peu tonnant. La mutiplication est bien une gnralisation de laddition. Pourquoi coterait-elle pareil ?

Evaluation des cots en squentiel

Dans un programme strictement squentiel,les boucles sont disjointes ou embotes : il ny a pas de rcursivit. Les temps dexcution sadditionnent : v alternative : (si C alors J sinon K) T(n) = TC(n) + max { TJ(n), TK(n) } v itration borne : (pour i de j k faire B) T(n) = ( k-j+1).(Tentte(n) + TB(n) ) + Tentte(n) )
entte est mis pour laffectation de lindice de boucle et le test de continuation. Le cas des boucles imbriques se dduit de cette formule.

Seules les oprations lmentaires sont galit de cot. Pour simplifier, on peut faire lhypothse que toutes les oprations ont un cot uniforme (mme si cela manque souvent de ralisme). Ce cot est alors constant car il ne dpend plus de rien. Pour un programme donn, les profileurs permettent de savoir quelles sont les instructions qui prennent le plus de temps (rgle des 90-10).

v itration non borne : (tant que C faire B) T(n) = #boucles . ( TB(n) + TC(n) ) + TC(n) (rpter B jusqu C) T(n) = #boucles . ( TB(n) + TC(n) ) Le nombre de boucles #boucles svalue inductivement. v appel de procdures :
on peut ordonner les procdures de sorte que la ime ait sa complexit qui ne dpende que des procdures j, avec j<i.

10

Evaluation des cots en rcursif

On sait que les algorithmes du type diviser pour rgner donnent lieu des programmes rcursifs. Comment valuer leur cot ? Il faut trouver : la relation de rcurrence associe

Variantes du temps dexcution

Temps dexcution dans le pire des cas Tpire(n) = maxn { T(n)

Exemple le cas le pire pour le tri rapide (quicksort) est quand le tableau est dj tri, le cas le pire pour le tri par slection est quand le tableau est tri dans lordre inverse.

la base de la rcurrence, en examinant les cas darrt de la rcursion et aussi ... la solution de cette quation

Temps dexcution en moyenne Tmoy(n) =

Techniques utilises : rsolution des quations de rcurrence ou de partition dj vue ou par les sries gnratrices.
Exemples (cf cours 5 : Suites rcurrentes) on avait valu le temps T(n) de la recherche dichotomique dans un tableau tri de n cases n1 : T(n) = 1 + log2(n) La complexit en temps pour rsoudre le problme des tours de Hano tait n0 : T(n) = 2n - 1

Sn

p(n) . T(n)

avec p(n) une loi de probabilit sur les entres. Frquemment, on utilise la loi de probabilit uniforme.

Tmoy&unif(n) = (1/#n)

Sn

T(n)

Exemple on suppose que lon emprunte une fois sur 2 chaque possibilit dune alternative.

Temps dexcution dans le meilleur des cas Tmeil(n) = minn { T(n) }

12

11

Exemple
1. 2. 3. 4.

(extrait du tri par slection)

1 affectation 1 aff.+ 1 comp. + (1 aff.+ 1 comp.).#boucles 1 comparaison . #boucles (si test vrai : 1 affectation) . #boucles

Estimation asymptotique
En complexit, on ne considre que des fonctions positives de IN dans IR. On ne veut pas valuer prcisment les temps dexcution (dautant que a dpend des machines). On se contente de trouver des approximations. On dit que f positive est asymptotiquement majore (ou domine) par g et on crit f = O ( g ) quand il existe une constante c, c>0, telle que pour un n assez grand, on a : f(n) c . g(n)
On dfinit symtriquement la minoration de f par g : f = W ( g ).

min i pour j de i+1 n faire si A[j] < A[min] alors min j

Dans le pire des cas, quand la table est trie par ordre inverse. 4 (n-i) + 3 Supposons que, sur les (n-i) tests, la (petite) moiti est value vrai. En moyenne, 4 (n-i)/2 + 3 (n-i)/2 + 3
Les notations prcdentes, appeles plancher et plafond donnent respectivement la moiti de largument arrondie lentier infrieur et la moiti de largument arrondie lentier suprieur.

Dans le meilleur des cas, quand le tableau est tri, on nexcute jamais linstruction min j. 3 (n-i+1)
13

On dit que f est du mme ordre de grandeur que g et on crit f = q ( g ) quand f = O ( g ) et g = O ( f )

14

Ordres de grandeurs
du plus petit au plus grand : O(1), O(log(n)), O(nx), O(n), O(n.log(n)),
avec O < x < 1 < c

Commentaires
En pratique, un algorithme complexit exponentielle est inutilisable. pour n pas trop grand, les algorithmes polynomiaux sont encore efficaces. 40000
35000

O(nc), O(cn), O(n!)

constant logarithmique

O(1) O(log(n)) O(n) O(n log(n)) O(n2) O(n3) O(2n)

la notation f = O(g) est scabreuse car elle ne dnote pas une galit mais plutt lappartenance de f la classe des fonctions en O( g ).
Exemple : = et = sans que lon ait 4n2+n = n2-3 partir dun n assez grand O(n2) 4n2+n n2-3 O(n2)

30000

linaire n log(n) quadratique cubique exponentiel

25000 20000 15000 10000 5000 0
60 80 100 120 140 160

2^(n/10) n.n 100 n n.log(n)

un algorithme est polynomial sil existe un entier p tel que son cot est O(np).
15

16

Proprits
Rflexivit

Exemples
Voici le temps de calcul dalgorithmes rcursifs classiques : recherche dichotomique dans un tableau de n cases T(n) = 1 + log2(n) soit T(n) =

Symtrie Transitivit

g = g =

O ( g ) q( g )
ssi g = q( f ) f = O( h ) f = q( h )

f = q( g )

O ( log2(n) )
2n -1

f = O ( g ) et f = q( g ) et

g = O( h ) alors g = q( h ) alors

problme des tours de Hano T(n) = soit

T(n) =

O (

2n )

Produit par un scalaire l>0, l . O ( g ) = O( g ) Somme et produit de fonctions O( f ) + O( g ) ) = O( max (f,g) ) O( f ) . O( g ) ) = O( f.g )

factorielle : temps linaire valuation de polynme (Horner) : linaire sur le degr produit de matrice/vecteur : temps quadratique. tri rapide (quicksort) : n.log(n)

17

18

Exemple
1.

Exemple
O (1) O (1) O (1) O (1) O (1) alors
2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19.
*

(suite)
O O O O O O O O O O O (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1)

1. 2. 3. 4. 5. 6. 7. 8. 9.

fonction fusion(L,K:liste):liste si L vide alors rsultat K sinon si K vide alors rsultat L sinon si elmCourant(L)< elmCourant(K)

O (1) rsultat concatne(elmCourant(L),fusion(suivant(L),K))O(1)+O(T(n-1) ) sinon rsultat concatne(elmCourant(K),fusion(L,suivant(K))O(1)+O(T(n-1) )

Si n=0, on excute les lignes 1,2,3 : temps O(1) Si n=1, on excute les lignes 1,2,4,5 : temps O(1) Si n>1, on excute 1,2,4,6,7 ou 1,2,4,6,8,9 : temps O(1) + T(n-1) Soit rsoudre lquation T(0) = a et T(n) = b + T(n-1). ... la rsolution donne un cot linaire : T(n) = n.b + a = O(n)

fonction split(L:liste): un couple de listes J,K listeVide si vide(L) alors rsultat (L,L) sinon si vide(suivant(L)) alors rsultat (L, listeVide) sinon i 1 tant que non listeVide(L) faire e = retire(L) si impair(i) alors ajoute (e,J) sinon ajoute (e,K) finsi i i + 1 fin tant que rsultat (J,K) finsi

O (1) O (1) O (1)

Si n=0 ou 1 : temps O(1) Si n>1, on excute la boucle tant que n fois : temps O(n) la fonction split a donc un cot linaire.
20

19

Exemple
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12.

(fin)
O O O O O O (1) (1) (1) (1) (1) (1)

procdure triFusion(L:liste): liste J,K listeVide si vide(L) alors rsultat L sinon si vide(suivant(L)) alors rsultat L sinon (J,K) = split(L) J triFusion(J) K triFusion(K) rsultat fusion(J,K) finsi

O(n) O(T(n/2)) O(T(n/2)) O(n)

on suppose que la taille de la liste est une puissance entire de 2. si n=0 ou 1 : lignes 1,2,3,4 ou 1,2,3,5,6 : temps O(1) si n>1 avec n = 2k : on excute les lignes 1,2,3,5,7,8,9,10,11. En
particulier, il y a deux appels des fonctions (8,11) et deux appels rcursifs (9,10)

On pose lquation : T(1) = a et n>1, T(n) = 2 T(n/2) + b.n la rsolution donne T(n) = a.n + b.n.log2 (n) donc le tri Fusion a un cot en O(n.log(n)) .

21