Analyse des algorithmes

Transcription

1 Chapitre 2 Analyse des algorithmes Analyser un algorithme consiste à calculer les ressources qui seront nécessaires à son exécution. Mais avant cela, il faut d abord s assurer que l algorithme est correct, c est-à-dire qu il calcule bien ce pourquoi il a été écrit. 2.1 Preuves de la correction d un algorithme Comment s assurer qu un algorithme calcule bien ce qu il est censé calculer? Comment s assurer qu un algorithme termine quelle que soit les données qui lui seront fournies en entrée? Les algorithmes sont su samment formalisés pour qu on puisse prouver qu ils possèdent les propriétés attendues de correction ou de terminaison. Les preuves sont facilitées lorsque les algorithmes sont bien écrits, et en particulier s ils sont décomposés en de nombreux sous algorithmes courts et bien spécifiés. Ce sont bien évidemment les structures itératives et les appels récursifs qui nécessitent le plus de travail Preuve de la correction d une structure itérative Considérons le schéma d algorithme suivant : 7

2 8 CHAPITRE 2. ANALYSE DES ALGORITHMES Algorithme 4: Structure itérative générique résultat : R début Initialisation # Point A tant que Condition faire # Point B1 Instructions # Point B2 fintq # Point C fin Un invariant de boucle est une propriété ou une formule logique, qui est vérifiée après la phase d initialisation, qui reste vraie après l exécution d une itération, et qui, conjointement à la condition d arrêt, permet de montrer que le résultat attendu est bien celui qui est calculé. Exemple 1 Pour l algorithme 2 du chapitre précédent, qui insère un élément x dans un tableau trié T [1,n], considérons la propriété I suivante : la juxtaposition des tableaux T [1,i] et T [i +2,n+ 1] 1 est égale au tableau initial et x est plus petit que tous les éléments du deuxième tableau La propriété est vérifiée après l initialisation (point A) puisque T [1,i] est égal au tableau initial (i = n), et que le second tableau T [i+2,n+ 1] est vide. 2. Si la propriété I est vraie au début d une itération (point B1), elle est vraie à la fin de cette itération (point B2) puisque le dernier élément T [i] du premier tableau passe en tête du second (l ordre n est pas modifié), et puisque l on a x<t[i] etquel indiceestmodifiéen conséquence. Si la condition reste vraie, alors la propriété est donc vérifiée au début de l itération suivante. 3. Si la condition est fausse (point C), on peut montrer que x est En e et, à tous les éléments du premier tableau. 1. si m>n, T [m, n] désigneuntableauvide. 2. propriété vraie si le deuxième tableau est vide.

3 2.1. PREUVES DE LA CORRECTION D UN ALGORITHME 9 c est vrai si i = 0, car le premier tableau est vide, c est vrai si i>0 et x T [i], car le tableau T [1,i]esttrié. Comme l invariant est vrai, x est à la fois à tous les éléments de T [1,i]et< à tous les éléments de T [i+2,n+1]. Il su t donc d écrire T [i + 1] = x pour obtenir le résultat attendu. Remarque : Pour prouver la correction d une boucle Pour, on peut remarquer que équivaut à Pour i:=1 à n faire Instructions i:=1 Tant que i<= n faire Instructions i:=i+1 et utiliser la technique précédente. Exemple 2 Pour prouver la correction de l algorithme 1, on considère l invariant de boucle suivant : T [1,j 1] est trié. 1. Après l initialisation, la propriété est vraie puisque j = 2etquele tableau T [1,j 1] ne contient qu un seul élément. 2. Supposons que T [1,j 1] soit trié au début d une itération. Après appel de l algorithme 2, le tableau T [1,j] est trié. Après l incrémentation de j, le tableau T [1,j 1] est trié. 3. Si la condition devient fausse, c est que j = n + 1. Le tableau T [1,n] est donc trié Preuve de correction d un algorithme récursif On prouve la correction d un algorithme récursif au moyen d un raisonnement par récurrence. Exemple 3 Pour prouver la correction de l algorithme 3, on e ectue une récurrence sur le nombre N = n m + 1 d éléments du tableau. si N = 1, alors m = n et on vérifie que l algorithme est correct dans ce cas ;

4 10 CHAPITRE 2. ANALYSE DES ALGORITHMES soit N 1. Supposons que le programme soit correct pour tout tableau de longueur apple N et considérons un tableau T [m, n] den +1 éléments : n m +1=N + 1. En particulier, m 6= n puisque N 1. Soit k = b m+n 2 c. Onam apple k<n.ene et, m<n) m< m + n 2 <n) m appleb m + n c = k<n. 2 Donc, les deux tableaux passés en argument des appels récursifs ont au plus N éléments. En e et, le premier a k m +1 éléments et k m +1 apple n m apple N ; le second a n k éléments et n k apple n m apple N. Par hypothèse de récurrence, quelque soit le résultat du test T [k] < x, l algorithme donnera une réponse correcte Exercices 1. Recherche du plus grand élément d un tableau (version itérative) : Algorithme 5: recherchemaxiter entrée : T [1,n] est un tableau d entiers. sortie : le plus grand élément de T [1,n]. début Max := T [1] pour i := 2à n faire si T [i] >Maxalors Max := T [i] retourner Max (a) Remplacez la structure itérative Pour par un Tant que. (b) Trouvez l invariant de boucle. (c) Prouvez la correction de l algorithme. 2. Recherche du plus grand élément d un tableau (version récursive) : Algorithme 6: recherchemaxrec entrée : T [1,n] est un tableau d entiers. sortie : le plus grand élément de T [1,n]. début si n =1alors retourner T [1] sinon retourner max(t [n],maxrec(t [1,n 1]))

5 2.2. COMPLEXITÉ DES ALGORITHMES 11 (a) Prouvez la correction de l algorithme par récurrence sur le nombre d éléments du tableau. 2.2 Complexité des algorithmes En plus d être correct, c est-à-dire d e ectuer le calcul attendu, on demande à un algorithme d être e cace, l e cacité étant mesurée par le temps que prend l exécution de l algorithme ou plus généralement, par les quantités de ressources nécessaires à son exécution (temps d exécution, espace mémoire, bande passante,... ). Le temps d exécution d un algorithme dépend évidemment de la taille des données fournies en entrée, ne serait-ce que parce qu il faut les lire avant de les traiter. La taille d une donnée est mesurée par le nombre de bits nécessaires à sa représentation en machine. Cette mesure ne dépend pas du matériel sur lequel l algorithme sera programmé. Mais comment mesurer le temps d exécution d un algorithme puisque les temps de calcul de deux implémentations du même algorithme sur deux machines di érentes peuvent être très di érents? En fait, quelle que soit la machine sur laquelle un algorithme est implémenté, le temps de calcul du programme correspondant est égal au nombre d opérations élémentaires effectuées par l algorithme, à un facteur multiplicatif constant près,etce, quelle que soit la taille des données d entrée de l algorithme. Par opérations élémentaires on entend les évaluations d expressions, les a ectations, et plus généralement tous les traitements en temps constant ou indépendant de l algorithme (entrées-sorties,... ). Le détail de l exécution de ces opérations au niveau du processeur par l intermédiaire d instructions machine donnerait des résultats identiques à un facteur constant près. Autrement dit, pour toute machine M, il existe des constantes m et M telles que pour tout algorithme A et pour toute donnée d fournie en entrée de l algorithme, si l on note T (d) le nombre d opérations élémentaires e ectuées par l algorithme avec la donnée d en entrée et T M (d) le temps de calcul du programme implémentant A avec la donnée d en entrée, mt (d) apple T M (d) apple MT(d). Soit, en utilisant les notations de Landau (voir section 8.2), T = (T M ). On peut donc définir la complexité en temps d un algorithme comme le nombre d opérations élémentaires T (n) e ectuées lors de son exécution sur des données de taille n. Il s agit donc d une fonction. On distingue

6 12 CHAPITRE 2. ANALYSE DES ALGORITHMES la complexité dans le pire des cas (worst case complexity) :T pire (n) est le nombre d opérations maximal calculé sur toutes les données de taille n ; la complexité dans le meilleur des cas (best case complexity):t min (n) est le nombre d opérations minimal calculé sur toutes les données de taille n ; la complexité en moyenne (average case complexity) :T moy (n) le nombre d opérations moyen calculé sur toutes les données de taille n, en supposant qu elles sont toutes équiprobables. Analyser un algorithme consiste à évaluer la ou les fonctions de complexité qui lui sont associées. En pratique, on cherche à évaluer le comportement asymptotique de ces fonctions relativement à la taille des entrées (voir section 8.2). En considérant le temps d exécution, dans le pire des cas ou en moyenne, on parle ainsi d algorithmes en temps constant : T (n) = (1), logarithmiques : T (n) = (log n), polylogarithmiques : T (n) = ((log n) c ) pour c>1, linéaires : T (n) = (n), quasilinéaires : T (n) = (n log n), quadratiques : T (n) = (n 2 ), polynomiaux : T (n) = (n k ) pour k 2 N, exponentiels : T (n) = (k n ) pour k>1. Si un traitement élémentaire prends un millionième de seconde, le tableau suivant décrit les temps d exécutions approximatifs de quelques classes de problèmes en fonction de leurs tailles. Taille n/ T (n) log 2 n n nlog 2 n n 2 2 n ms 0.01 ms 0.03 ms 0.1 ms 1 ms ms 0.1 ms 0.6 ms 10 ms siecles ms 1 ms 10 ms 1 s ms 10 ms 0.1 s 100 s ms 100 ms 1.6 s 3 heures ms 1 s 20 s 10 jours D un autre point de vue, le tableau ci-dessous donne la taille des problèmes de complexité T que l on peut traiter en une seconde en fonction de la rapidité de la machine utilisée (F est le nombre d opérations élémentaires exécutées par secondes).

7 2.2. COMPLEXITÉ DES ALGORITHMES 13 F /T (n) 2 n n 2 nlog 2 n n log 2 n En pratique, un algorithme est constitué d instructions agencées à l aide de structures de contrôle que sont les séquences, lesembranchements et les boucles (nous verrons plus tard comment traiter le cas particulier des fonctions récursives, mais de toutes façons toute fonction récursive s écrit aussi itérativement). Le coût d une séquence de traitements est la somme des coûts de chaque traitement. Le coût d une structure itérative est la somme des coûts des traitements e ectués lors des passages successifs dans la boucle. Par exemple il arrive fréquemment que l on e ectue n fois une boucle avec des coûts dégressifs (Cn, C(n 1),..., C). Dans ce cas T (n) = C(n+(n 1)+(n 2)+...+1) = C nx i=1 n(n + 1) i = C = (n 2 ). 2 Le coût d un embranchement (si test alors traitement1 sinon traitement2) est le coût du plus coûteux des deux traitements Exemples d analyse d algorithmes Taille d un tableau Un tableau de n constantes de taille k (entiers, réels,...) a une taille de kn. Mais on peut facilement démontrer que f(n) = (g(n)) ssi f(kn) = (g(kn)), lorsque g est constante, linéaire, quasilinéaire ou polynomiale. Par ailleurs, si f(n) est exponentielle, c est a fortiori aussi le cas de f(kn). On pourra donc supposer, dans les calculs de complexité, que la taille d un tableau de n éléments constants est n. L algorithme d insertion d un élément dans un tableau trié Dans le pire des cas, celui où l entier à insérer est plus petit que tous les éléments du tableau, l algorithme 2 requiert 2n +2a ectations,

8 14 CHAPITRE 2. ANALYSE DES ALGORITHMES 2n + 1 comparaisons d entiers, n soustractions et n + 1 addition, n + 1 évaluations d une expression booléenne pour un tableau de n éléments. En supposant de plus que chaque instruction élémentaire s exécute en un temps constant, on en déduit que T pire (n) = (n). L algorithme d insertion ordonnée est linéaire dans le pire des cas : à des constantes additives et multiplicatives près, le temps d exécution est égal au nombre d éléments du tableau. On voit facilement que T min (n) = (1) : en e et, dans le meilleur des cas, l élement à insérer est plus grand que tous les éléments du tableau et la boucle n est pas exécutée. Si l on suppose que l élément à insérer et un élément pris au hasard dans le tableau, son insertion nécessitera en moyenne n/2 comparaisons. On aura donc, T moy (n) = (n), soit une complexité moyenne du même ordre que la complexité du pire des cas. L algorithme de tri par insertion Dans le pire des cas, celui où le tableau en entrée est déjà trié, mais par ordre décroissant, l algorithme nécessite n 1 comparaisons et a ectations pour la condition de la boucle Pour n 1 appels à l algorithme d insertion ordonnée, pour des tailles de tableaux variant de 1 à n 1. À des constantes additives et multiplicatives près, le temps d exécution dans le pire des cas de l algorithme de tri par insertion est donc égal à (n 1) (n 1) = n 1+ n(n 1) 2 = (n 2 ) soit en appliquant la remarque sur l égalité à des constantes additives et multiplicatives près de la taille des données et du nombre d éléments du tableau, T pire (n) = (n 2 ). On voit facilement que T min (n) = (n), cas où le tableau est déjà ordonné par ordre croissant. En e et, chaque appel à l algorithme d insertion ordonnée est exécuté en temps constant. Si tous les éléments du tableau en entrée sont tirés selon la même loi de probabilités, on peut montrer que T moy (n) = (n 2 ). Autrement dit, s il peut arriver que le temps d exécution soit linéaire, il y a beaucoup plus de chance qu il soit quadratique en la taille des données en entrée.

9 2.2. COMPLEXITÉ DES ALGORITHMES 15 L algorithme de recherche dichotomique Si le tableau contient un seul élément, l algorithme exécutera 2 comparaisons (coût total : c 1 ) Si le tableau contient n>1 éléments, l algorithme exécutera 3 opérations arithmétiques, une a ectation et une comparaison entre 2 entiers (coût total : c 2 ), et un appel récursif sur un tableau possédant dn/2e ou bn/2c éléments, soit dn/2e dans le pire des cas. On en déduit que si n>1, T pire (n) =T pire (dn/2e)+c 2. Cette équation est simple à résoudre lorsque n est égal à une puissance de 2 : T pire (2 h )=T pire (2 h 1 )+c 2 = T pire (2 h 2 )+2c 2 =...= c 1 + hc 2. Dans le cas général, soit n = a h 2 h a a 0 l écriture de n en base 2 : a h =1et0apple a i apple 1 pour 0 apple i<h.ona On en déduit que 2 h apple n<2 h+1 et donc 2 h 1 appledn/2e apple2 h. c 1 + hc 2 apple T pire (n) apple c 1 +(h + 1)c 2. En remarquant que h = (log 2 n), on en déduit que T pire (n) = (log 2 n). La recherche dichotomique d un élément dans un tableau trié se fait donc en temps logarithmique. L analyse d algorithmes conduit souvent à des équations récursives de la forme T (n) = at (dn/be) + f(n) ou at (bn/bc) + f(n) (2.1) où b>1, a>0 et f est une fonction. Le théorème 2 de la section 8.4 donne la solution de ces équations dans le cas général. Dans l exemple précédent, on se trouve dans le cas (2) du théorème, avec a =1etb = 2 : on retrouve que T pire (n) = (log 2 n). Il est essentiel de savoir utiliser ce théorème mais il est aussi utile de pouvoir retrouver rapidement le résultat cherché. Nous décrivons ci-dessous quelques calculs approximatifs, à partir de l équation simplifiée qui recouvrent un grand nombre de cas courants. T (n) =at (n/b)+f(n), (2.2)

10 16 CHAPITRE 2. ANALYSE DES ALGORITHMES Calculs à la main de la complexité d une fonction définie par une relation de récurrence Nombre d itérations : si l on itère k fois l équation 2.2, l argument de T devient n/b k.onan/b k =1ssik = log b n. Il faut donc environ log b n itérations pour trouver la constante de référence T (1). On en déduit le développement suivant : T (n) =f(n)+af(n/b)+ + a k 1 f(n/b k 1 )+ (a log b n ). Si a = 1, on a T (n) =f(n)+f(n/b)+ + f(n/b k 1 ). Si f(n) =c, Si f(n) =n, T (n) =kc = (log b n). Si a = b, on a T (n) =n(1 + 1 b b k 1 )=nb b k b 1 = (n). T (n) =f(n)+bf(n/b)+ + b k 1 f(n/b k 1 )+ (n). Si f(n) =c, T (n) =c(1 + b + + b k 1 )+ (n) = n 1 + (n) = (n). b 1 Si f(n) =n, T (n) =n( ) + (n) =nk + (n) = (n log b n). Si a>b, on peut écrire a = b h avec h>1. On a T (n) =f(n)+af(n/b)+ + a k 1 f(n/b k 1 )+ (n h ). Si f(n) =c, T (n) =1+a + + a k 1 + (n h )= nh 1 a 1 + (nh )= (n h ).

11 2.2. COMPLEXITÉ DES ALGORITHMES 17 Si f(n) =n, T (n) =n(1+a/b+ +(a/b) k 1 )+ (n h )=n (a/b)k 1 a/b 1 + (nh )= (n h ). Ce que l on peut résumer dans le tableau suivant, T (n) a =1 a = b a = b h f(n) =c log b n n n h f(n) =n n nlog b n n h Pour les autres cas, utilisez le théorème. Le tri par fusion Le tri par fusion est un algorithme qui applique la stratégie diviser pour régner. Le tableau à trier est divisé en deux sous-tableau de même taille (à un élément près), l algorithme est appelé récursivement sur chacun de ces sous-tableaux, et les tableaux résultants sont alors fusionnés. Algorithme 7: TriFusion entrée : T [1,n] est un tableau d entiers, n 1. résultat : les éléments de T sont ordonnés par ordre croissant. début si n>1 alors T 1 := trif usion(t [1, bn/2c]) T 2 := trif usion(t [bn/2c +1,n]) T := Fusion(T 1,T 2 ) On peut montrer que l algorithme de fusion est linéaire en fonction du nombre n d éléments. Soit T (n) la complexité de l algorithme en fonction de n. L équation de récurrence correspondante est T (n) =T (dn/2e)+t (bn/2c)+n + c. Méthode générale (voir le théorème 2 de la section 8.4). On est dans le cas 2 puisque : f(n) =n + c, a = b = 2, log b a =1etf(n) =O(n). Donc T (n) = (n log 2 n). Solution en développant directement la récurrence.

12 18 CHAPITRE 2. ANALYSE DES ALGORITHMES On peut considérer l équation plus simple suivante : T (n) =2T (n/2)+n. On a : T (n) =2T (n/2) + n =4T (n/4) + 2n = =2 k T (n/2 k )+kn. Les appels récursifs se terminent lorsque n ' 2 k, soit k ' log 2 (n) :ilya au plus log 2 (n) appels récursifs imbriqués. On en déduit que T (n) ' nc + n log 2 (n). Le terme dominant étant n log 2 (n), on en déduit que T (n) = (n log 2 (n)). n 2x n n/2 n/2 2x n hauteur : dlog 2 ne log n n/4 n/4 n/4 n/4 2x n n/8 n/8 n/8 n/8 n/8 n/8 n/8 n/ Figure 2.1 Arbre des appels récursifs pour l algorithme de tri par fusion. Solution intuitive. Si l on pressent que la complexité de la fonction T vérifiant T (n) = 2T (n/2) + n est (n log 2 n), on peut essayer de vérifier que cette intuition est juste, c est-à-dire, s il existe une fonction T vérifiant à la fois l équation de récurrence et T (n) = (n log 2 n). Posons T (n) =a n log 2 n + bn + c et essayons ensuite de fixer les constantes au moyen de l équation de récurrence. On a : T (n) =a n log 2 n + bn + c =2T (n/2) + n = 2[a n/2 log 2 n/2+bn/2+c]+n = a n log 2 n an + bn +2c + n. On en déduit que a =1etc = 0, b n étant pas contraint. La fonction T (n) =n log 2 n vérifie donc l équation T (n) =2T (n/2) + n.

13 2.2. COMPLEXITÉ DES ALGORITHMES Exercices Exercice 1 Montrez que 1. n log n = O(n 2 ), 2. n log n = (n), 3. n + sin(n) n. 4. A t-on 2 n = (e n )? 5. A t-on e log 2 (n+1) =!(n)? Exercice 2 Quelles sont les classes de complexité des fonctions suivantes : 1. f(n) =2n 3 +4n , 2. f(n) = log (n 2 +3n 1), 3. f(n) =2 log 2 (n2 +1) 2. Exercice 3 Quelle est la complexité de l algorithme suivant : Algorithme 8: début pour i := 1à n n faire u := i tant que u>1 faire u := u/2 Exercice 4 Calculez la complexité de la fonction qui calcule le produit de deux matrices carrées A et B de n lignes et n colonnes. Exercice 5 Prouvez la correction de l algorithme récursif suivant : Algorithme 9: expo entrée : x est un réel et n est un entier sortie : x n. début si x =0alors retourner 0 si n =0alors retourner 1 si n est pair alors retourner expo(x x, n/2) sinon retourner x expo(x x, (n 1)/2)

14 20 CHAPITRE 2. ANALYSE DES ALGORITHMES Combien de multiplications faut-il e ectuer pour calculer x 20? pour calculer x 2p? pour calculer x 2p 1? Quelle est la complexité de l algorithme - en terme de nombre de multiplications? Exercice 6 Écrivez un algorithme qui prend en entrée une matrice carrée n n et retourne la liste des coordonnées des cases dont la valeur est à la fois maximale sur leur ligne et minimale sur leur colonne. Quelle est la complexité de cet algorithme? Exercice 7 : Calcul de l élément majoritaire d un tableau. Etant donné un ensemble E de n éléments, on dit qu un élément e est majoritaire dans E si le nombre d occurrences de e est strictement supérieur à n/2. 1. Quel est la complexité d un algorithme qui teste si un élément e est majoritaire ou non dans E? On cherche maintenant à savoir s il existe un élément majoritaire, et si oui, à le déterminer. 2. Proposez un algorithme de complexité quadratique. 3. On considère maintenant l approche suivante, basée sur le principe diviser pour régner : pour rechercher l élément majoritaire éventuel dans l ensemble E, on répartit les n éléments de E dans deux ensembles (approximativement) de même taille E 1 et E 2. Montrez que si un élément est majoritaire dans E, alors il est majoritaire dans E 1 ou dans E 2. Ecrivez une procédure de calcul correspondant à cette idée. Quelle est sa complexité? Une troisième méthode sera proposée au prochain TD.