Complexité algorithmique

Définitions Notion de complexité : Il est souhaitable de pouvoir évaluer les performances d’une solution (algorithme) à une problématique. Complexité théorique -> Terminaison & Correction Complexité algorithmique -> utilisation des ressources (mémoires et temps)

Temps d’exécution Plusieurs facteurs : Les données à traiter Software (compilateur , logiciel , langage utilisé, …) Hardware (Vitesse des bus, microprocesseur,…) La complexité algorithmique du programme

Temps d’exécution Quantifier le temps -> modèle de la machine !!! Premier Modèle : TAM : temps d’accès à la mémoire TADD : temps d’une addition ou d’une soustraction TMUL : temps d’une multiplication TDIV : temps d’une division TCMP : temps d’une comparaison à la valeur 0 TES : temps d’une liaison entrée-sortie

Temps d’exécution Algorithme de calcul du PGCD Entrées : a entier , b entier Sorties : x entier Si a>b Alors   x ← a y ← b Sinon x ← b y ← a Tant que y≠ 0 Faire r ← x % y x ← y y ← r résultat x   Soustraction et comparaison à 0 2 affectations 2 affectations comparaison à 0 Affectation et une division 2 affectations

Temps d’exécution Algorithme de calcul du PGCD Entrées : a entier , b entier Sorties : x entier Si a>b Alors   x ← a y ← b Sinon x ← b y ← a Tant que y≠ 0 Faire r ← x % y x ← y y ← r résultat x   TCMP+TADD 2 TAM 2 TAM TCMP TAM+TMUL 2 TAM

Temps d’exécution Algorithme de calcul du PGCD Entrées : a entier , b entier Sorties : x entier Si a>b Alors   x ← a y ← b Sinon x ← b y ← a Tant que y≠ 0 Faire r ← x % y x ← y y ← r résultat x   TCMP+TADD +2TAM n*(TCMP +3 TAM +TMUL)

Temps d’exécution Modèle simplifié: Toutes les instructions de bases prennent une unité de temps spécifique à la machine Unité de Temps (UT) de l’ordre de la nanosecondes pour les ordinateurs personnels

Temps d’exécution ≈(4+5*n )*1 UT Algorithme de calcul du PGCD Entrées : a entier , b entier Sorties : x entier Si a>b Alors   x ← a y ← b Sinon x ← b y ← a Tant que y≠ 0 Faire r ← x % y x ← y y ← r résultat x   Temps d’exécution ≈(4+5*n )*1 UT

Temps d’exécution instruction basique (affectation, comparaison à 0,…) -> 1 UT Séquence de p instructions -> p UT Si b Alors p Sinon q -> b+Maximum(p,q) UT Pour i allant de 1 à n Faire p -> n*p UT Tant que b Faire p -> difficulté

Temps d’exécution Tant que b Faire p -> difficulté Au meilleur des cas : Nmini (b+p) UT borne inférieur du coût Au pire des cas : Nmaxi (b+p) UT borne supérieure du coût Cas moyen: Nmoy (b+p) UT

Temps d’exécution Tant que y≠ 0 Faire r ← x % y x ← y y ← r Au meilleur des cas X=Y, et donc je sors au bout d’1 itération Nmini =1 Au pire des cas X et Y sont 2 nombres consécutifs de Fibonnaci et donc Nmaxi= E(log(X)/log(φ)) Pour la cas moyen, le problème est un peu plus difficile et non traité dans ce cours. n*(TCMP +3 TAM +TMUL)

Complexité asymptotique 2 algorithmes A et B résolvant le même problème de complexités respectives 100n et n2. Quel est le plus efficace ? Pour n < 100, B est plus efficace. Pour n = 100, A et B ont la même efficacité. Pour n > 100, A est plus efficace. Remarquons que plus n devient grand, plus A est efficace devant B. (taille faible-> calcul inutile)

Complexité asymptotique Supposons par exemple qu’on a déterminé que ce temps était proportionnel à n2 + 3n. Pour n ⩾ 3, on a n2+ 3n ⩽ 2n2, la quantité n2 + 3n est donc bornée, à partir d’un certain rang, par le produit de n2 par une constante. On dit alors que la quantité de n2 +3n est « un grand O de n2 » 𝒏 𝟐 +𝟑𝒏=𝑶 𝒏 𝟐

Complexité asymptotique   Nom courant Temps n=109 n=106 n=103 O(1) Temps constant 1 ns O(log n) Temps logarithmique 20 ns 10 ns 7 ns O(n) Temps linéaire 1 s 1 ms 1 μs O(n2) Temps quadratique 32 ans 17 min O(nk) Temps polynomiale 32 milliards d’années k=3 30 ans   k=3  k=3 O(2n) Temps exponentielle infini   Nom courant Temps Commentaires n=109 n=106 n=103 O(1) Temps constant 1 ns Le temps ne dépend pas des données traitées, ce qui est assez rare ! La plupart des données ne sont même pas lues ! O(log n) Temps logarithmique 20 ns 10 ns 7 ns En pratique l’exécution est quasi-instantanée. Bien souvent à cause du codage binaire, c’est en fait en log2(n) que l’on voit apparaître le temps O(n) Temps linéaire 1 s 1 ms 1 μs Le temps d’exécution d’un tel algorithme ne devient supérieur à 1 min que pour des données de taille comparable à la mémoire vive actuelle. Le problème de la gestion mémoire interviendra avant celle du temps d’exécution O(n2) Temps quadratique 32 ans 17 min Acceptable pour des données <106 O(nk) Temps polynomiale 32 milliards d’années k=3 30 ans Ici nk est le terme du plus haut degré d’un polynôme en n. Il n’est pas rare de voir des complexités du type n3 ou n4 O(2n) Temps exponentielle infini Ce type d’algorithme est impraticable !! sauf si la taille des données est très petites (n<50). Comme pour la complexité logarithmique, la base de l’exponentielle ne change fondamentalement rien à l’inefficacité de l’algorithme.

Complexité asymptotique Données : n (entier) Premier ← vrai Pour i allant de 2 à Entier(√n+1) Faire : Si n%i=0 alors Premier← Faux Résultat Premier Pire des cas : Résultat au bout de √n itérations pour les nombres premiers Meilleur des cas : Résultat au bout d’une itération pour les nombres pairs

Etude de cas : Polynôme 1 Algorithme polynome1(x) #évaluation d'un polynôme de degré connaissant la liste de ces coefficients constant a : liste # la liste de ces coefficients de longueur n+1 eval, puissance : réel début eval←a[0] pour k allant de 1 à n faire: puissance←1 pour i allant de 1 à k faire: puissance←puissance*x eval←eval + a[k]*puissance retourner eval fin

Etude de cas : Polynôme 1 Complexité : pour k allant de 1 à n faire: puissance←1 pour i allant de 1 à k faire: puissance←puissance*x eval←eval + a[k]*puissance Σ(2k+4)UT=n(n+1)+4n UT = O(n²) Complexité polynomiale de degré 2 ou quadratique O(n²) 1 UT O(k) 2 UT 3 UT

Etude de cas : Polynôme 2 Algorithme polynome2(x) #évaluation d'un polynôme de degré connaissant la liste de ces coefficients constant a : liste # la liste de ces coefficients de longueur n+1 eval, puissance : réel début eval←a[0] puissance←1 pour k allant de 1 à n faire: puissance←puissance*X eval←eval + a[k]*puissance retourner eval fin

Etude de cas : Polynôme 2 Complexité: pour k allant de 1 à n faire: puissance←puissance*X eval←eval + a[k]*puissance Σ(5)UT=5n UT = O(n) complexité linéaire Pour aller plus loin : les opérations sont une addition et 2 accès mémoires (UT petit) et 2 multiplications (UT pus grand) O(n) 2 UT 3 UT

Etude de cas : Polynôme HORNER Algorithme polynome_horner(x) #évaluation d'un polynôme de degré connaissant la liste de ces coefficients constant a : liste # la liste de ces coefficients de longueur n+1 eval : réel début eval←a[n] pour k allant de 1 à n faire: eval←eval*x + a[n-k] retourner eval fin

Etude de cas : Polynôme HORNER Complexité : pour k allant de 1 à n faire: eval←eval*x + a[n-k] retourner eval Σ(3)UT=3n UT = O(n) complexité linéaire Pour aller plus loin : les opérations sont une addition et un accès mémoire (UT petit) et pour une multiplication (UT pus grand) . C’est l’algorithme le plus performant en complexité temporelle pour évaluer les polynômes. Pour X=2 et a une liste de bit, nous avons l’évaluation rapide d’un nombre binaire. 3 UT

Etude de cas : Racine carrée 1 Algorithme racine_carre1( n:entier) #retourne la partie entière de la racine carre de l'entier r: entier début r ←0 Tant que (r+1)*(r+1) <= n faire r←r+1 retourner r Fin Montrer que si ces algorithmes se terminent alors il calcule bien la partie entière de la racine carrée. (On pourra regarder l'inéquation ) Déterminer la complexité de ces algorithmes.   1UT 5 UT 2UT 1UT

Etude de cas : Racine carrée 1 Correction Pré-conditionnement r=0 donc r*r<=n Hérédité rk* rk <=n est vrai. Or à l’entrée de la boucle on vérifie (rk +1)*(rk +1) < n donc (rk+1)*(rk+1) <= n est vrai Post-conditionnement (rk +1)*(rk +1) > n donc si la boucle se termine je vérifie bien rk<=Racine(n) Complexité L’évolution du compteur est linéaire . La complexité est en O(Racine(n))  

Etude de cas : Racine carrée 2 Algorithme racine_carre2( n:entier) #retourne la partie entière de la racine carre de l'entier début r, s ←1,n Tant que (r+1)*(r+1) <= n faire c← (r+s)//2 si c*c <= n alors r ← c sinon s ←c retourner r fin Monter que l’on vérifie toujours l’inéquation : r² <n . Montrer que si cet algorithme se termine alors il calcule la partie entière de la racine carrée Déterminer la complexité de cet algorithme

Etude de cas : Racine carrée 2 Correction Pré-conditionnement r=0 s=n donc r²<=n<s² Hérédité rk² <=n <sk² est vrai. Le point milieu est affecté au borne supérieure ou inférieure suivant leur position par rapport à racine(n) donc l’inégalité sera forcément vérifiée après la boucle donc rk+1² <= n <sk+1² est vrai Post-conditionnement (rk +1)*(rk +1) > n donc si la boucle se termine je vérifie bien rk<=Racine(n) Complexité L’intervalle le plus petit entre r et s est de 1. s-r=1 A chaque itération cet intervalle diminue de 2. Donc si on va en sens inverse il faut multiplier par 2 l’intervalle finale pour arriver à la taille de l’intervalle initiale n. Donc on cherche l’entier k correspond à : 2k>n k ln(2)>ln(n) La complexité est donc en O(ln(n))

Etude de cas : Racine carrée 3 Algorithme racine_carre3( n:entier) #retourne la partie entière de la racine carre de l'entier r : entier début r ←1 Tant que (r+1)² <= n ou n < r² faire r ← (r+n/r)//2 retourner r Fin Montrer que si cet algorithme se termine alors il calcule la partie entière de la racine carrée Déterminer la complexité de cet algorithme

Etude de cas : Racine carrée 3 Correction : Pré-conditionnement r=(n²+6n +1)/(4n+4)<(n+1)/2 n <r² Hérédité Invariant à démontrer (décroissante minorée ) n <rk² et rk<rk-1 rk+1=(rk +n/rk)/2 < (rk +rk)//2= rk rk+1² =(rk² +1/ rk² )//2+n>n Post-conditionnement En sortie je vérifie forcément r²<=n<(r+1)²  

Etude de cas : Racine carrée 3 Complexité : Pour déterminer la complexité, on va déterminer l’évolution de l’erreur entre la suite et la limite: rk+1 -√n =(rk +n-2rk√n)/(2rk)= (rk -√n )²/(2rk)<(1/2√n) (rk -√n )² Erreur relative : ek+1 =(rk+1 /√n)-1 / < ek ² /2 L’évolution de l’erreur est donc quadratique ek+1<Aek ² <A (A² ek-14 )ε1 <A1+2+…+2k-1e12k avec A=1/2 ek+1<(Ae1) 2k La convergence est très rapide à partir du moment où l’erreur relative n’excède pas 100%. Donc dès que rk < 2 √n  

Etude de cas: crible d’Erastothène Algorithme crible_erastothene (n: entier) début Pour i allant de 1 jusqu’à n faire test[i] ← vrai test[1] ← faux Pour i allant de 2 jusqu’à n faire Si test[i] alors k←2 Tant que k*i≤n faire test[k*i] ← faux k←k+1 liste←[ ] Pour i allant de 1 jusqu’à n faire si test[i] alors liste←liste,i # ajoute à la liste le nombre i retourner liste fin O(n) 1UT 1 UT 3 UT 2 UT 1 UT 2 UT 1UT O(n)

Etude de cas: crible d’Erastothène Pour i allant de 2 jusqu’à n faire Si test[i] alors k←2 Tant que k*i≤nfaire test[k*i] ← faux k←k+1 𝑖=1 𝑛 𝑘=1 𝑘∗𝑖≤𝑛 1 = 𝑖=1 𝑛 𝑘=1 𝑘≤ 𝑛 𝑖 1 = 𝑛 2 + 𝑛 3 +…+1=𝑛 ln 𝑛 Cette partie a donc une complexité en O(nln(n)). 1UT 3 UT 1 UT 2 UT 2 UT

Exercice : Triangle pythagoricien Déterminer un algorithme permettant de trouver l’ensemble des triangles rectangles dont le périmètre est l’entier naturel p. Déterminer les preuves de terminaison et de correction ainsi que la complexité de votre algorithme.