Analyse d’algorithmes

Slides:



Advertisements
Présentations similaires
Théorie des graphes.
Advertisements

Algorithmes et structures de données avancés
Introduction à l’Algorithmique
Calculs de complexité d'algorithmes
Algorithmique Résume.
GEF 435 Principes des systèmes d’exploitation
Performances 1 Évolution : Performance. Performances 2 Évolution : Mémoire.
Séminaire Florin Périer Alain Gély LIMOS
INTRODUCTION.
Les sous-programmes Chapitre n° 5: Objectifs : Activité:
Chapitre II.Rappels mathématiques et complexité
Utilisation des tableaux
Les bases de l’Algorithmique
Principes de programmation (suite)
Conception et analyse des algorithmes
Introduction à l’algorithmique
Démarche de résolution de problèmes
Analyse des algorithmes: une introduction
Les algorithmes: complexité et notation asymptotique
Methode de Tri efficace
ALGORITHMIQUE en classe de seconde
IFT-2000: Structures de Données Introduction à lanalyse dalgorithmes Dominic Genest, 2009.
Algorithmique et Programmation
Analyse d’Algorithmes
Structures de données IFT Abder Alikacem La classe string Département dinformatique et de génie logiciel Édition Septembre 2009 Département dinformatique.
Structures de données IFT-2000
Mesurer l’efficacité des algorithmes
Introduction à l’algorithmique
Systèmes Superscalaires et VLIW
IFT Complexité et NP-complétude
Gestion de Fichiers Tri Interne Efficace et Tri Externe.
CSI3525: Concepts des Languages de Programmation
STRUCTURES DE DONNÉES Maxime CROCHEMORE
Les systèmes multiplateformes
LIFI-Java 2004 Séance du Jeudi 9 sept. Cours 1. La notion de langage Décrire une tâche à effectuer –programme Écrire à un haut niveau –facile pour lutilisateur.
Analyse des algorithmes: une introduction. La question abord é e dans ce chapitre est la suivante: Comment choisir parmi les diff é rentes approches pour.
Efficacité des algorithmes
Efficacité des algorithmes
Partie II Sémantique.
Tutorat en bio-informatique Le 21 novembre Exercices 2 et 3 (MAT1400) - solutions Chapitre 11.7, Analyse - concepts et contextes vol. 2 27) Cherchez.
ASI 3 Méthodes numériques pour l’ingénieur
Structures de données IFT-2000 Abder Alikacem La récursivité Semaine 5 Département dinformatique et de génie logiciel Édition Septembre 2009.
Structures de données IFT Abder Alikacem Gestion des exceptions Module 2 Département dinformatique et de génie logiciel Édition Septembre 2009.
Analyse des Algorithmes
Structures de données IFT-2000 Abder Alikacem Arbres de recouvrement minimum Département dinformatique et de génie logiciel Édition Septembre 2009 JFK.
Structures de données IFT-2000 Abder Alikacem La récursivité Département d’informatique et de génie logiciel Édition Septembre 2009.
Analyse d’algorithmes
Structures de données IFT-2000 Abder Alikacem Introduction Semaine 1 Département d’informatique et de génie logiciel Édition Septembre 2009.
Efficacité des algorithmes
1 Notations Asymptotiques Et Complexité Notations asymptotiques : 0 et  Complexité des algorithmes Exemples de calcul de complexité.
O-notation 1. Introduction 2. O-notation 3. Opérations 3.1 Somme 3.2 Produit 4. Règles générales 5. Exemple 6.Analyse des algorithmes récursifs 6.1 Dilatation.
INTRODUCTION.
Algorithmes et Programmation
Programmation linéaire en nombres entiers
INF3500 : Conception et implémentation de systèmes numériques Pierre Langlois Performance de circuits.
D.E ZEGOUR Ecole Supérieure d’Informatique. Problèmes de décision Concepts de base Expressions régulières Notation particulière pour exprimer certaines.
GF-11: Tri Interne Efficace et Tri Externe
2008/ Plan du cours 1.Introduction –Contenu du cours 2.Logique mathématique –Calcul propositionnel –Calcul des prédicats –Logique floue et aide à.
Algorithmique : Introduction
INF3500 : Conception et implémentation de systèmes numériques Pierre Langlois Performance de circuits.
MATHÉMATIQUES DISCRÈTES Chapitre 2 (section 2) François Meunier DMI.
2005/2006 Structures de Données Introduction à la complexité des algorithmes.
Pour les boucles FOR on a fait intervenir la boucles TANT QUE équivalentes dont on connaît calculer le temps d’exécution. Toutes le procédures de comptage.
Architecture et technologie des ordinateurs II
Structures de données IFT-2000
Structures de données IFT-2000 Abder Alikacem Laboratoire #1 Département d’informatique et de génie logiciel Édition Septembre 2009.
CSI2510 Structures de données et algorithmes Analyse des algorithmes
Algorithmes parallèles
L'exécution d'un programme nécessite l'utilisation des ressources de l'ordinateur : temps de calcul pour exécuter les opérations, et l'occupation de la.
Complexité algorithmique
Transcription de la présentation:

Analyse d’algorithmes Structures de données IFT-2000 Abder Alikacem Analyse d’algorithmes Édition Septembre 2009 Département d’informatique et de génie logiciel

Plan Notions d’analyses d’algorithmes Introduction Efficacité des algorithmes Analyse d’algorithmes Notation Ω (big-omega) Notation Θ Notation o (little-oh) Notation O (big-oh) Baromètres Comparaison entre les classes de complexité Règles de simplification Espace mémoire Compromis espace/temps

Algorithmique Conception de méthodes pour la résolution de problèmes Description des données Description des méthodes Preuve de bon fonctionnement Complexité des méthodes Efficacité : temps de calcul, espace nécessaire, ... Complexité intrinsèque, optimalité Réalisation - implémentation Organisation des objets Opérations élémentaires

Efficacité des algorithmes Habituellement on mesure l’efficacité d’un algorithme (correct) par sa vitesse. C’est-à-dire la durée que met l’algorithme à produire ses résultats. On veut savoir combien de temps cela prend de résoudre une instance I du problème P: données(I) + Algorithme(P) ==> résultat(I). temps mis ?

Efficacité des algorithmes Ici, on s’intéresse au temps de calcul pour résoudre I: en microsecondes, cycles d’horloge, nombre d’instructions exécutées, etc.. On prend en compte la taille des données(I): en bits, entiers, nombres d’enregistrements... Parfois, on considère aussi la mémoire nécessaire.

Efficacité des algorithmes Approche empirique: mesure de performances. essayer l’algorithme sur différents jeux de données bien choisis. Avantages: résultats réalistes. Inconvénients: coûteux et long dépend du processeur, de l’OS et de la charge dépend de l’implémentation pas toujours généralisable.

Efficacité des algorithmes Approche algorithmique: estimer le nombre de pas de l’algorithme en fonction de la taille des données. Avantages: résultats généraux: on ne dépend pas du processeur, de l’OS ou de l’implémentation Estimation rapide et peu coûteux évite de se fourvoyer. Inconvénients: prédictions approximatives.

Efficacité des algorithmes Les approches empiriques et algorithmique sont complémentaires. Utiliser l’approche algorithmique pour déterminer comment le temps de calcul varie avec la taille des données. Utiliser l’approche empirique afin d’obtenir un temps d’exécution précis. (associé à une implantation, à un système d'exploitation , et à un type de compilateur particuliers) Avantage: estimer le temps que prend l’algorithme pour des tailles de données plus grands que ceux des tests effectifs.

Efficacité des algorithmes Comment choisir parmi les différentes approches pour résoudre un problème? Exemple: Liste chaînée ou tableau? 2 objectifs à atteindre: Concevoir un algorithme facile à comprendre, coder et déboguer. Concevoir un algorithme qui utilise de façon efficace les ressources de l’ordinateur.

Efficacité des algorithmes Objectif (1): concerne le génie logiciel Objectif (2): Algorithmes et structures de données. Lorsque l’objectif (2) est important, comment peut-on mesurer l’efficacité d’un algorithme?

Analyse d’algorithme Analyse empirique: exécuter le programme Analyse assymptotique d’algorithmes Ressources critiques: temps, espace mémoire,... Facteurs affectant le temps d’exécution: machine, language, programmeur, compilateur, algorithme et structure de données. Le temps d’exécution dépend du volume de l’entrée.

Analyse d’un algorithme Analyse détaillée : Avantage :Très précise Désavantage : Long à calculer Solution: Analyse asymptotique du comportement de l’algorithme lorsque le(s) paramètre(s) de l’algorithme tendent vers l’infini: Avantage: Parfois facile à calculer Désavantage: Parfois moins précis Mesure indépendante de l'implémentation : Temps d'exécution d'un algorithme = fonction(taille du problème)

Notation W (big-omega) Détermine une borne inférieure Définition formelle : f(n) = W (g(n)) s’il existe deux constantes positives n0 et c tel que cg(n) <= f(n) pour tout n>n0

Notation W (big-omega) Étant donné deux fonctions f(n) et g(n), f(n) = W(g(n)) ssi:  b > 0,  n, f(n) / g(n) >= b Limn®¥ f(n) / g(n) Î Â+ È ¥ Exemple f(n) = 3n2+6n+4 et g(n) = n+3 limn®¥ f(n) / g(n) = ¥ \ 3n2+6n+4 est W(n+3) 3n2+6n+4 est W(n) On dit « f(g) est en oméga g(n) »

Notation Q Relation d’équivalence, correspond à la complexité exacte Définition formelle : f(n) = Q (g(n)) s’il existe trois constantes positives n0,c1 et c2 tel que c1g(n) <= f(n) <= c2g(n) pour tout n>n0

Notation Q Étant donné deux fonctions f(n) et g(n), f(n) = Q (g(n)) ssi:  a,b > 0,  n, a <= f(n) / g(n) <= b Limn®¥ f(n) / g(n) Î Â+ Exemple: f(n) = 3n2+6n+4 et g(n) = n2+3 limn®¥ f(n) / g(n) = ¥ \ 3n2+6n+4 est Q (n2+3) 3n2+6n+4 est Q (n2) Autre propriété: f(n) = Q(g(n)) ssi f(n) = O(g(n)) et f(n) = W(g(n))

Notation o (little-oh) Détermine une borne supérieure stricte Définition formelle : f(n) = O(g(n)) s’il existe deux constantes positives n0 et c tel que f(n) < cg(n) pour tout n>n0

Notation O (big-oh) Détermine une borne supérieure Définition formelle : f(n) = O(g(n)) s’il existe deux constantes positives n0 et c tel que f(n) <= cg(n) pour tout n>n0

Notation O (big-oh) Cherche une fonction simple qui décrit le comportement de l’algorithme dans le pire cas. Exemples : O(n), O(n2),O(log n) L’analyse est simplifié selon les règles suivantes: Les constantes sont éliminées Seul le monôme avec le degré le plus élevé est conservé Exemple: f(n) = 3n2+5n+4 est O(n2)

Exemple void triSelection(int tab[MAXTAB], int n) { int PositionMin, temp, i, j; for (i = n-1; i > 0; i--) PositionMin = i; for (j = 0; j < i; j++) if (tab[j] < tab[PositionMin]) PositionMin = j; } temp = tab[i]; tab[i] = tab[PositionMin]; tab[PositionMin] = temp; Exemple

Baromètres // i * a //b2 void triSelection(int tab[MAXTAB], int n) { int PositionMin, temp, i, j; for (i = n-1; i > 0; i--) PositionMin = i; //b1 for (j = 0; j < i; j++) if (tab[j] < tab[PositionMin]) PositionMin = j; } temp = tab[i]; tab[i] = tab[PositionMin]; tab[PositionMin] = temp; Qu’est-ce qu’un baromètre? Comment ça fonctionne? Comment choisir le choisir ? // i * a //b2

Baromètres Qu’est-ce qu’un baromètre? C’est une instruction qui s’exécute au moins autant de fois que chacune des autres. Comment ça fonctionne?: Sélectionne un ensemble d’instructions significatives B={b1…bk} On détermine le nombre d’exécution de chacun des baromètres dans B Temps total est la somme du nombres de d’exécution de chaque baromètre Comment choisir l’ensemble B? Mettre systématiquement certains types d’instructions(boucles,conditions,etc.) Estimer leurs nombres d’exécution maximal et minimal selon que l’on calcul le meilleur ou le pire cas. Simplifier B en gardant seulement les instructions qui s’exécutent le plus souvent.

Baromètres Boucle tant que (pour): chaque fois qu’on passe dessus, il s’exécute le nombre de fois que la condition est vraie+1 (quand la condition est fausse). Bloc interne d’un while: chaque fois qu’on passe sur le while, on passe sur ses instructions autant de fois que la condition est vraie. Bloc interne d’un si: chaque fois qu’on passe sur le si et que la condition est vraie, on passe sur ses instructions Autres instructions: chaque fois qu’on passe dessus, elles s’exécutent une fois.

Exemple (suite) for (i = n-1; i>0; i--) { Coût b1 /* PositionMin = i */ Coût i*a; /* pour exécuter la boucle interne*/ Coût b2; /* pour l'échange de tab[i] et tab[PositionMin] */ }

Exemple (suite) Exemple (suite) b = b1 + b2

f(n) = an2 + bn + c a = 0.0001724, b = 0.0004, c = 0.1 n f(n) an2 % du n2 125 2.8 2.7 94.7 250 11.0 10.8 98.2 500 43.4 43.1 99.3 1000 172.9 172.4 99.7 2000 690.5 689.6 99.9

Retour sur la notation O( ) (big-oh) Évaluer le coût d'un algorithme  Rechercher la fonction g(n) qui est la plus proche au dessus ou égale à f(n). Nous dirons alors f(n) est O(g(n)).

Notation O(g(n)) (big-oh) Pour un nombre n assez grand f(n)  an2 Temps d'exécution d'un algorithme A est f(n) = an2 + bn + c g(n) = n2 On écrit : A est O(n2) On lit : l'algorithme A tourne en O(n2) Classes : O(1), O(n), O(n2), O(n3), O(log n), …

Notation O(g(n)) (big-oh) Classes : O(1), O(n), O(n2), O(n3), O(log n), … 2n n 2 n f(n) log n 1 n

Comparaison entre les classes x VS log(x)

Comparaison entre les classes 50 45 40 35 30 x 25 x log( x ) 20 15 10 5 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 x VS x log(x)

Comparaison entre les classes x2 VS x log(x)

Comparaison entre les classes x VS x2 VS x3

Comparaison entre les classes O(1) < O(log(n)) < O(n) < O(nlog(n)) < O(n2) < O(n3) < O(2n) < O(10n)

Comparaison entres les classes O(1). Constant ou borné parfait. O(log(n)). Logarithmique excellent O(n). Linéaire très bon O(n log(n) ) bon. O(na) polynomial acceptable O(an) exponentiel inacceptable O(n!) factoriel beurk.

Augmenter la puissance du PC ?

Augmenter la puissance du PC

Meilleur algorithme ou ordinateur? On suppose que l’ordinateur utilisé peut effectuer 106 opérations à la seconde

Exemple (suite et fin) b = b1 + b2 L’algorithme est en O(n2)

Exemple: chercher le minimum dans un tableau d’entiers int minimumOn2(int tableau[],int taille) { int i,j; for(i=0;i<taille;i++) j=0; while(j<taille && tableau[i]<=tableau[j] ) j++; } if(j == taille) return tableau[i]; return tableau[i]; int minimumOn(int tableau[],int taille) { int i,min = tableau[0]; for(i=0;i<taille;i++) if( tableau[i]<min) min = tableau[i]; } return min; Algorithme #1 Algorithme #2

Autres exemples O(n) Fusionner(x,y) n = taille(x)+taille(y) pour i=1:n …. v(i) = ….. ….. fin Ab=c O(n2) pour i=1:n s = 0; pour j=i:n s =s+A(i,j)*b(i) Fin c(i)=s fin Résoudre(P(n)) Si n = 1 ,...c’est fini Sinon A=Résoudre(P(1:n/2)) B=Résoudre(P(n/2+1:n)) Fusionner(A,B) O(nlog2n)

Simplifier les séries Sommes ou produits avec un nombre variable de termes. Série Formule Résultat Exemple O() constante k=1..N a aN 3+3+...+3(10 fois) N somme de logs k=1..N log(k) log(N!) log(2)+log(3)+..log(100) N log(N) arithmétique k=1..N k N(N+1)/2 1+2+...+10 N2 somme de carrés k=1..N k2 N(N+1)(2N+1)/6 1+22+32+..102 N3 somme de puissances k=1..N ka (a entier)   1+23+33+..103 (a=3) Na+1  de polynômes de degré a k=1..N Pa(k) k=1..N k(k+1)..(k+a) géométrique binaire k=0..N 2k 2N+1-1 1+2+4+..+128 2N géométrique entière k=0..N ak (a entier) (aN+1-1)/(a-1) 1+3+9+..+81 (a=3) factorielle k=1..N k N!2N (N/e)N 1*2*..*100 NN+0.5

Pire cas, meilleur cas et cas moyen Toutes les entrées d’une longueur donnée ne nécessitent pas le même temps d’exécution. Exemple. Recherche séquentielle dans un tableau de taille n: Commencer au début du tableau et considérer chaque élément jusqu’à ce que l’élément cherché soit trouvé. Meilleur cas: O(1) Pire cas: O(n) Cas moyen: O(n/2)

Règles de simplification 1. Toujours négliger les constantes multiplicatives: 2n2 = O(n2) 2. Négliger les termes d’ordre inférieur: 5n2 + 3n = O(n2) + O(n) = O(n2) 3. O(n2) x O(n3) = O(n5)

Règles de simplification f(n) O(g(n)) et g(n)  O(h(n)), alors f(n)  O(h(n)).

Règles de simplification f(n)  O(kg(n)) où k >0 est une constante alors f(n)  O(g(n)).

Règles de simplification f1(n)  O(g1(n)) et f2(n)  O(g2(n)), alors f1(n) + f2(n)  O(max(g1(n), g2(n))). Exemple: n + nlog n  O(nlog n)

Règles de simplification f1(n)  O(g1(n)) et f2(n)  O(g2(n)) alors f1(n)*f2(n)  O(g1(n) * g2(n)) Exemple: (3n2 +3)(n2+5nlog n)  O(n4)

Règles de simplification Si p(n) est un polynôme de degré k alors p(n)  (nk)

pour toute constante k>0 Règles de simplification logk (n)  O(n) pour toute constante k>0

logk(n) k logk−1(n) logk(n) logk(n) = O(n) cn ≤ 1 cn lim lim = cn n→∞ k(k − 1)logk−2(n) = n→∞ cn (règle de l’Hôpital) ... = k! lim = = cn n→∞

Exemples Exemple 1: a = b; Temps constant: (1). Exemple 2: somme = 0; for (i=1; i<=n; i++) somme += n; Temps: (n)

Exemples Exemple 3: somme = 0; for (i=1; i<=n; i++) for (j=1; j<=i; j++) somme++; Temps: (1) + O(n2) = O(n2) On peut montrer : (n2)

Exemples Exemple 4: somme = 0; for (j=1; j<=n; j++) for (i=1; i<=n; i++) somme++; for (k=0; k<n; k++) A[k] = k; Temps: (1) + (n2) + (n) = (n2)

Exemples Exemple 5: somme = 0; for (k=1; k<=n; k*=2) for (j=1; j<=n; j++) somme++; Temps: (nlog n)

Exemples lSum = 0; for( int i = 0; i < n; ++i ) lSum++; lSum = 0; for( int j = 0; j < n; ++j) lSum++;

Exemples lSum = 0; for( int i = 0; i < n; ++i ) lSum++; for( int j = 0; j < n; ++j) lSum++; lSum = 0; for( int i = 0; i < n; ++i ) for( int j = 0; j < n*n; ++j) lSum++;

Exemples lSum = 0; for( int i = 0; i < n; ++i ) for( int j = 0; j < i; ++j) lSum++; lSum = 0; for( int i = 0; i < n; ++i ) for( int j = 0; j < n*n; ++j) for( int k = 0; k < j; ++k) lSum++;

Exemples lSum = 0; for( int i = 1; i <= n; ++i ) for( int j = 1; j < i*i; ++j) if( j % i == 0) for( int k = 0; k < j; ++k) lSum++;

Analyse de problèmes Borne supérieure: Borne supérieur sur le meilleur algorithme connu. Borne inférieure: Borne inférieure sur tous les algorithmes possibles. Exemple: Trier un tableau de taille n nécessite O(n) étapes et peut se faire en O(nlog n) étapes.

Temps de calcul Exemple T(n) = O(n4). De combien le temps de calcul augmente-t-il si n est multiplié par 10 ? T(n) = O(n4) = cn4 T(10n) = c(10n)4 = 104 cn4 = 10 000 T(n)

Logarithmes logb(n) = k ⇔ bk = n logb(n) = loga(n) / loga(b) logb(n) = O(log(n)) (la base ne compte pas) Le log apparaît lorsque systématiquement, on découpe le problème en deux morceaux de même taille

Logarithmes et exposants log(xy) = log(x) + log(y) log(xa) = alog(x) a(b+c) = abac abc = (ab)c

Temps de calcul Exemple T(n) = O(n logn). De combien le temps de calcul augmente-t-il si n est multiplié par 10 ? T(n) = cn log(n) T(10n) = c(10n) log(10n) T(10n) = 10cn log(n) + 10cn log(10) T(10n) = 10T(n) + dn

Recherche binaire données initialement triées point milieu

Analyse par télescopage T(n) = T(n/2)  + O(1) T(n/2) = T(n/4)  + O(1) T(n/4) = T(n/8)  + O(1) …. = …. T(2) = T(1)  + O(1)

Analyse par télescopage T(n) = T(n/2)  + O(1) T(n/2) = T(n/4)  + O(1) T(n/4) = T(n/8)  + O(1) …. = …. T(2) = T(1)  + O(1)

Analyse par télescopage T(n) = T(n/2)  + O(1) T(n/2) = T(n/4)  + O(1) T(n/4) = T(n/8)  + O(1) …. = …. T(2) = T(1)  + O(1)

Analyse par télescopage T(n) = T(n/2)  + O(1) T(n/2) = T(n/4)  + O(1) T(n/4) = T(n/8)  + O(1) …. = …. T(2) = T(1)  + O(1)

Analyse par télescopage T(n) = T(n/2)  + O(1) T(n/2) = T(n/4)  + O(1) T(n/4) = T(n/8)  + O(1) …. = …. T(2) = T(1)  + O(1)

Analyse par télescopage T(n) = T(n/2)  + O(1) T(n/2) = T(n/4)  + O(1) T(n/4) = T(n/8)  + O(1) …. = …. T(2) = T(1)  + O(1) log n ⇒ T (n)= T (1) +  O(1) = O(log n) i=1

Temps de calcul Exemple T(n) = O( log n). De combien le temps de calcul augmente-t-il s i n est multiplié par 1000 ? T(n) = c log(n) T(1000n) = c log(1000n) T(1000n) = c log(n) + c log(1000) T(1000n) = T(n) + 10c

Code source template <typename Comparable> int binarySearch( const vector<Comparable> & a, const Comparable & x ) { int low = 0; int high = a.size( ) - 1; int mid; while( low < high ) mid = ( low + high ) / 2; if( a[ mid ] < x ) low = mid + 1; else high = mid; } return ( low == high && a[ low ] == x ) ? low : NOT_FOUND;

Limitation de l’analyse Si on pense que T(n) = Θ (f(n)), on peut valider expérimentalement T(n)/f(n) = c Considérez des n suffisamment grands Lors de l’analyse, on choisit souvent le pire des cas, mais celui-ci peut être significativement pire que le cas moyen !

Limitation de l’analyse T(n)/f(n)

Espace mémoire La quantité d’espace mémoire utilisé peut aussi être étudiée à l’aide de l’analyse asymptotique. En général: Temps: Algorithme manipulant les structures de données. Espace: Structure de données

Compromis espace/temps Il est souvent possible de réduire le temps d’exécution au prix d’augmenter l’espace mémoire et vice versa. Fichiers compressés Table des valeurs d’une fonctions Insérer un nœud dans une liste chaînée Espace disque: Un programme sera d’autant plus rapide qu’il requiert peu d’accès disque.