Ecole Nationale Polytechnique Département Génie Industriel Année Universitaire 2011/2012

Transcription

1 . Ecole Nationale Polytechnique Département Génie Industriel Année Universitaire 2011/2012 Cours Algorithmique et Programmation Complexité Algorithmique Savoir résoudre un problème est une chose. Le résoudre efficacement en est une autre.. Plan du chapitre 1. Théorie de la complexité Critères d évaluation d un algorithme Efficacité et Complexité. Approches d évaluation de la complexité. 2. Complexité algorithmique. Analyse et notations asymptotiques. Classes de la complexité algorithmique. 3. Complexité d un algorithme. Complexité des structures de contrôle. Complexité d algorithmes récursifs. 4. Complexité d un problème. Classes P, NP,NP-complets (NPC). Approches de résolution des problèmes NP complets. 5. Conclusion. Théorie de la complexité Critères d évaluation d un algorithme : Exactitude Convergence et stabilité Simplicité de l implémentation. Efficacité Soit : P : un problème décidable ou calculable. M: une méthode pour résoudre le problème P. Objectifs Evaluer l efficacité de la méthode M Comparer M avec une autre méthode M Indépendamment de l environnement (machine, système, compilateur, programmeur...) Exemple : Calculer la puissance m d un nombre x Méthode 1 Méthode 1 (Algo. naïf) : x 11 =x*x*x*x*x*x*x*x*x*x*x x0 = 1; xi = x* xi-1 i >0 Méthode 2 x0 = 1; xi =x (i/2)* x (i/2) si i est pair; xi =x*(x (i-1)/2 ) 2 si i est impair x 11 =x*(x 5 ) 2 = x* (x* (x 2 ) 2 ) 2 Efficacité et Complexité d un algorithme Calculer la complexité d un algorithme consiste à trouver combien coûte un appel à cet algorithme : Combien de ressources l algorithme utilise-t-il. On a deux ressources critiques: Temps de calcul. Espace mémoire. La complexité à deux dimensions : 1. Complexité temporelle : T(Algo), Temps nécessaire pour transformer les données du problème considéré en un ensemble de résultats. 2. Complexité spatialle S(Algo) : Taille en mémoire nécessaire pour stocker les structures de données utilisées. Le facteur temps d'exécution est l'élément qualitatif le plus perceptible par l'utilisateur. ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 1 ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 2

2 Approches d évaluation de la complexité Deux approches peuvent être utilisées: 1. Approche expérimentale, 2. Approche mathématique. Approche expérimentale Écrire un programme implémentant l algorithme. Exécuter le programme pour différentes instances du problème Limitations de l approche expérimentale Nécessité d implémenter les # algorithmes. Nombre limité d instances de test. Mesures dépendantes des facteurs et détails de l implémentation Approche mathématique. Analyser le temps (ou l espace) en se concentrant sur l algorithme et l influence de la taille du problème. Modèle de calcul : 1. Modèle de machine idéale (Modele de Turing) avec : a. Une mémoire infinie, b. Accès à la mémoire en temps constant. 2. L unité de mesure de la complexité en temps est l opération fondamentale pour le problème de calcul particulier. a. Temps discret, pas continu. b. Temps logique, pas réel. Définition : Le temps d'exécution d'un algorithme sur une entrée particulière est le nombre d opérations élémentaires exécutées. On admet que toute opération élémentaire prend un temps constant. Choix des paramètres : 1. Il faut choisir au préalable les opérations élémentaires. 2. Il faut déterminer la taille du problème. Problème Opération fondamentale Taille de l entrée Addition Calcul de la somme des éléments d un tableau Recherche d un élément dans une liste Multiplication de matrices Addition des entiers binaires Comparaison entre l élément et les entrées de la liste Multiplication scalaire réelles Opération binaire nombre d éléments dans le tableau nombre d éléments dans la liste dimension des matrices N*M nombre de bits pour représenter les entiers Exemple 1: calcul de a^n Algorithme Puissance (entier a, entier n) var i, x : Entiers; début x 1 ; // c1 pour (i=0; i<n; pas =1) // n fois. x x*a; //c2 retourne x // c3 fin algorithme Exemple 2 : Recherche Séquentielle Opération fondamentale; x x*a Complexité : C1+N*C2+C3 Rechercher x dans un tableau A de n éléments Algorithme : SRecherche(A,x) Début K 1 ; // c1 tant que (k <= n) et A[k]!= x (A[k]!= x) // c2+c3 Faire k:=k+1 ; // c4 fin Tantque si k>n alors k:=-1;// c5 +c6 Fin Opération fondamentale; Complexité : =? Complexité Temporelle Soit A un algorithme {Dn} l ensemble des entrées E de taille n. E une entrée de taille n CoûtA(E)= C(n) = Nombre d opérations élémentaires exécutées par l algorithme A sur une entrée E. Le calcul exact de la complexité C(n) s avère très difficile, voire impossible. Il y a souvent un nombre infini d instances possibles de taille n. ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 3 ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 4

3 Il y a lieu de distinguer trois mesures de complexité: 1. Complexité du pire cas TMax (n). : Borne supérieure du coût d exécution Une garantie de performances. 2. Complexité moyenne TMoy (n) : Espérance sur l'ensemble des entrées 3. Complexité du meilleur cas : TMin (n) : une estimation optimiste du coût d exécution. Calcul de la complexité: La complexité en coût pire cas TMax (n) = Max{Coût A(E), Taille (E)= n } La complexité en coût meilleur cas La complexité en moyenne TMin (n) = Min{Coût A(E), Taille (E)= n } TMoy (n) = {Coût A(E)*Prob(E), Taille (E)= n } Avec Prob(E) = probabilité d avoir en entrée une instance E parmi toutes les données de taille n. Opération de base : Comparaison de x avec un élément de A. T(n) = 1 si A[1] = x : Meilleur des cas. T(n) = n si A[n] = x : Pire des cas. 1 <= T(n) <= n dans tous les cas. Complexité en moyenne de RS : On suppose que : Prob [x dans A ] = p Ensemble de Données Coût Probabilité Pour 1 <= i <= n A[i] = x Coûti(Réussite) =i p/n Si i == n+1 Sortie avec échec Coût(Echec)=n 1-p Complexité moyenne TMoy (n)= Coûti(Réussite)*p/n+Coût(Echec)*(1-p) 1 <= i <= n Exemple Problème : Recherche Séquentielle d un élément x dans un tableau de N éléments Entrées : A,n,x ; où A est un tableau A [n], x : l élément recherché Sortie : l indice de x dans A (- 1 si échec). Algorithme : SRecherche() Début K 1 ; tant que (k <= n) et (A[k]!= x) Faire k:=k+1 ; fin Tantque si k>n alors k:=-1; Fin Recherche Séquentielle : Complexité moyenne T MOY (n) = (p/n) i + n.(1-p) 1 <= i <= n T MOY (n) = p.n.(n+1)/(2n) + n.(1-p) T MOY (n) = p.(n+1)/(2) + n.(1-p) Si p=1 T MOY (n)= (n+1)/2 Si p=1/2 T MOY (n)= (3n+1)/4 L'analyse mathématique de T MOY (n) souvent délicate. ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 5 ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 6

4 Analyse asymptotique Le coût exact T(n) est très difficile à mesurer Etude de l évolution de la complexité lorsque la taille du problème augmente (i.e. tend vers l infini). La vraie question: Simplifications : Principe d invariance : Comment évolue la complexité en fonction de la taille du problème? La complexité d un algorithme est indépendante de son implémentation (choix de la machine, du langage,... ). Les facteurs multiplicatifs constants ne sont donc pas pris en compte dans la mesure de la complexité. Exemple : Si la taille n du problème est multipliée par 10, Comment évolue la complexité T(n)= f(n)? Si f(n) = k f(10n) = 10.k=k1. Si f(n) = k.n f(10n) = k.(10n) = 10(k.n) = 10.f(n) = k2.n Si f(n) = k.n^2 f(10n) = k.(10n)^2 = 100.f(n)=. k3.n^2. Ordre de grandeur : L'ordre de complexité d'une fonction nous donne un ordre de grandeur de son taux de croissance. L algorithme le moins complexe sera très certainement le plus rapide Notations asymptotiques Comportement limite de T(n) lorsque l'argument tend vers une valeur particulière ou l'infini, On utilise les notations asymptotiques : O(grand oh), Ω(grand oméga) et Θ(grand Thêta) Notations asymptotiques taux de croissance des complexités Notation grand O (notation de Landau) : T(n) est en O(f(n)) s il existe deux constantes positives c et n0 telles que: T(n) <= c.f(n) n >= n0. Signification: T(n) est de l'ordre de f(n) T(n) O(f) ou bien T(n) = O(f) Le nombre d'opérations effectuées est borné par c.f(n), Exemples T(n)=a.n 2 + b.n + c, T(n)=O(n 2 ). Quelques cas : T(n)=n2+10 n O(n2) pour n n0=1 avec c=11. En effet : n n n n 2 = 11 n 2 donc c=11 et n0=1 T(n)=n n O(n2) pour n n0=10 avec c=2. en effet : n n n 2 +n n = 2 n 2 donc c=2 et n0=10 en effet : n n 2 donc c=1 et n0=1 T(n)=n O(n2) pour n 1 ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 7 ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 8

5 Notation grand Ω (Omega) : T(n) est en Ω(f(n)) s il existe deux constantes positives c et n0 telles que: T(n) c.f(n) pour tout n >= n0. On utilise la notation Ω pour décrire le meilleur des cas. Remarques T(n)= Ω ( f1(n)) T(n) >= c1.f1(n) T(n)= O ( f2(n)) T(n) <= c1.f2(n) f1(n) est une borne inférieure asymptotique pour Ω(f(n)). f2(n) est une borne supérieure asymptotique pour O(f(n)). Notation grand Θ (Theta): La notation Θ permet d encadrer asymptotiquement T(n) à des constantes multiplicatives près. T(n) est en Θ(f(n)), si et seulement si T(n) Ω(f(n)) et T(n) O(f(n)) T = Θ(f) s il existe des constantes positives c1, c2 et n0 tel que: c1 f(n) T(n) c2 f(n) pour tout n >= n0. Méthode pratique Il est généralement plus pratique d utiliser la méthode suivante Si la limite L existe. L=Lim T(n)/f(n) n + Selon la valeur de L L =r (fini) Avec r ]0,+ [ alors T = Θ(f) L= 0 alors T = Ο(f) et T Θ(f) L= + alors T = Ω (f) et T Θ(f) Notes: Θ(f(n))=Ω(f(n)) O(f(n)) letaux de croissance de T(n) est équivalent à celui de f(n) : Notation Θ classement en sous-ensembles disjoints (classes d équivalence) : Θ(1), Θ(n). Exemples T(n) =3n 2 100n + 6 N Classe Justification 1 T(n) = Ο(n2) 3n 2 > 3n 2 100n T(n) = Ο(n3) 0,01n 3 > 3n 2 100n T(n) Ο(n) c n < 3n 2 lorsque n > c. 4 T(n) = Ω(n2) 2,99n 2 < 3n 2 100n T(n) Ω(n3) n 3 > 3n 2 100n T(n) = Ω(n) 100n < 3n 2 100n T(n) = Θ(n2) T(n) = Ο(n 2 ) et T(n) = Ω (n 2 ) 8 T(n) Θ(n3) T(n) = Ο(n 3 ) seulement 9 T(n) Θ(n) T(n) = Ω(n) seulement ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 9 ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 10

6 Exercice Soient : A un algorithme, T1(n) le temps pris par A pour résoudre une instance de taille n sur un ordinateur, T2(n) le temps pris par le même algorithme sur la même instance sur un ordinateur k fois plus rapide. Montrer que O(T1(n)) = O(T2(n)), Solution Soit T1(n) =O(f(n)) il existe c1 R* et n0 N tel que T1(n)<= c1.f(n) n>= n0. Comme T1(n)=k. T2(n), on a : k.t2(n)<= c1.f(n) T2(n)<= c1/k.f(n) =c2.f(n) n>=n0. ce qui veut dire que T2(n) =O(f(n)) soit T2(n) =O(f(n)) il existe c2 R* et n0 N tel que T2(n)<= c2.f(n) n>= n0. Comme T1(n)=k. T2(n), on a : T1(n)<= k.c2.f(n) T1(n)<= c2.k.f(n) =c1.f(n) n>=n0. Propriétés des notations asymptotiques. T1 O f1, T2 O f2 T1 O f, T2 O f T1 O f1, T2 O f2 Réflexivité de O Dualité entre O et Ω. Transitivité : =[O Θ Ω ] T1+T2 O(max(f1+f2)) T1+T2 O(f) T1*T2 O(f1*f2)) T n =O T(n)). Classes complexité algorithmique f n = O g n g n = Ω(f(n)) f n = g n et g n = h n f(n) = (h(n)) O 1 complexité constante O log n complexité logarithmique. O n complexité linéaire. O n.log n complexité quasi linéaire. O n 2 complexité quadratique. O n 3 complexité cubique. O n p complexité polynomiale. O nlog n complexité quasi polynômiale. O a n, a>=2 complexité exponentielle. O n! complexité factorielle. Les fonctions de croissance les plus lentes sont listées en premier. Θ 1 Θ lg n Θ n Θ n lg n Θ n 2 Θ n 3 Θ n k Θ a n Θ n!. où a > 1 et k > 3 ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 11 ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 12

7 Exemples Exemples: soit T n =p n,k. p n,k = ak.n k + ak-1.n k-1 + a2.n 2 + a1.n +a0 donne une complexité de = O(n k ) T(n) = a.n 2 + b.n+c T(n) =O (n 2 ) T(n) = a.n k + log(n) T(n) = O (n k ) T(n) = a.n + b.n.log(n)+c T(n) = O (n.log(n)) Temps d exécution en fonction de la taille du problème Les temps sont donnés à titre indicatif (Une op./ 10 nanosecondes : Src. Wikipédia) En pratique : Importance des constantes Exemple O(1000 x n 30 ). Taille des données traitées à temps constant. Analyse de la complexité d un algorithme. Soit A un algorithme permettant de résoudre un problème P. Soit T n le pire temps de calcul de A pour une instance de taille n. Estimation de T(n) : On considère que toute opération élémentaire coûte O(1). On travaille à constante multiplicative près. On ignore les termes d ordres inférieurs. Règle générale, L analyse d'un algorithme se fait de l'intérieur vers l'extérieur. On analyse les instructions individuelles, puis les structures qui les englobent, etc., jusqu à obtenir le résultat pour l'algorithme dans son ensemble. Analyse des diverses structures de contrôle Complexité d une séquence Début Traitement1 T1(n) Traitement2 T2(n). Traitement2 Tm(n) Fin T(Séquence) = T1(n) + T2(n)+ Tm(n) T(n)= coûts.(traitements) Complexité asymptotique T1(n)=O(Max(T1(n), T2(n),,Tm(n)) Exemple : double VSphere (const float r) { double volume; const double PI = ; // (c1) volume = 4.0/3*PI*r*r*r; // (c2) return volume; // (c3) } Complexité de VSphere() T(n)=O(c1+3*c2+c3)= O(c) =O(1). Un algorithme efficace est beaucoup plus intéressant L'important n'est pas la valeur exacte entre les parenthèses suivant le O, mais le fait que cette valeur soit constante qu'une machine puissante. ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 13 ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 14

8 Complexité d'une instruction conditionnelle. Soit l alternative suivante : SI (Condition) ALORS Tc Traitement1 T1 SINON Traitement2 T2 FIN La complexité sera alors T Alternative = Tc Condition) + Max(T1, T2) Exemple : Probleme : Calcule du maximum de deux entiers Entrée: Entier1,Entier2 : Entiers Sortie: Maximum : Entier Début si Entier1<Entier2 alors Maximum Entier2 sinon Maximum Entier1 Fin Complexité d'une instruction répétitive Dans le cas général : T Itérations = coûts des passages successifs par chaque itération Itérations déterministes : le nombre de boucle est dé ini à l'entrée de la boucle La complexité est égal au nombre d'itérations multiplie par la complexité du corps de la boucle (instruction pour) Exemple 1: Problème : Évaluer une fonction polynomiale : méthode de Hörner Entrée Un tableau p[0, n + 1] de valeurs (polynôme), une valeur x0 Sortie La valeur p(x0) ALGORITHME HORNER(p,x):entier; VARIABLES i: entier; y: valeur; DEBUT y 0; pour (i =0 à n) FAIRE y y * x + p[n - i]; Θ(1) FIN POUR RETOURNER y; FIN. COMPLEXITÉ T(n) = Θ(n) Exemple 2: Var T :Un tableau T[0,n-1] d Entiers Min, Max : Entiers Debut min=max=t[0]; pour ( i=1 a n-1) faire Si (t[i]>max) max=t[i]; // Tmax(n) = 2.(n-1) Sinon // Tmin(n) = n-1 Si (t[i]<min) min=t[i]; Fsi // Tmoy=3(n-1)/2 Fsi Fin pour Fin Itérations indéterministes : Itérations conditionnées par une expression booléenne. 1. Analyser la boucle pour obtenir une borne supérieure (resp. inferieure) pour le nombre d'itérations. 2. Utiliser cette information comme pour une itération déterministe Dans le pire cas le nombre d'itérations est maximal (peut être difficile a calculer) Dans le meilleur des cas le nombre d'itérations est de 0 (pour le tantque) ou de 1 (pour le répéter jusqu'à ce que). En moyenne : il faut calculer tous les cas possibles et faire la moyenne (souvent très difficile à calculer) Exemple1: Sequence1 i=1 Tantque (i<n) faire Operation i=2*i; Fin Tantque l opération s exécute «k» fois tel que 2^(k-1)<n<=2^k Dans le pire des cas on a n=2^k donc k=log2 n T(n) =O( Log2 (n)). Exemple2: Sequence2 Pour (i=1 à n) k=1 Tantque (k<n) faire Operation k=2*k; Fin Tantque Fin Pour Exemple n=8: i = 1 2^0 = 1 opération i = 2 2^1 = 1 opération i = 4 2^2 = 1 opération i = 8 2^3 = Fin de la boucle Exécution N fois la boucle Tantque La boucle interne qui s exécute «k=log2(n)» fois est répétée n fois (boucle pour ) T(n) =O( n.log2 (n)). ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 15 ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 16

9 Complexité d algorithmes récursifs Etablir une équation récursive donnant T(n) en fonction de T(n - 1) ou de T(n/d), Résoudre l équation de récurrence Equation Cas Solution T(n) = c.t(n-1) + b.n k c = 1 T(n) = O(n k+1 ) T(n) = c.t(n-1) + b.n k c > 1 T(n) = O(c n ) T(n) = c.t(n/d) + b.n k c > d k T(n) = O(n log d (c) ) T(n) = c.t(n/d) + b.n k c = d k T(n) = O(n k log(n)) T(n) = c.t(n/d) + b.n k c < d k T(n) = O(n k ) Exemple 2 : Fonction Factoriel récursive T(0)=c1 =O(1) T(n)= T(n-1)+c1+c2 = T(n-1)+ O(1) On obtient donc l équation T(n) = O(1) + max{o(1), T(n 1) + O(1) T(n)= O(1) + T(n 1) + O(1) = T(n 1) + O(1). Elle correspond au cas T(n) = c.t(n-1) + b.n k (avec c = 1 et k = 0). T(n) = O(n). Arbre de récursivité Arbre de récursivité ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 17 ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 18

10 Complexité d un problème Problèmes du GI Problèmes décisionnels : Problèmes de recherche et d'optimisation Problèmes dont la réponse est de type binaire oui/non, vrai/faux, 1/0, ). Problèmes qui comportent une injonction de la forme«trouver un élément tel que» et dont la réponse est de type numérique. Complexité d un problème On appelle complexité du problème, la borne inférieure du temps de calcul de tous les algorithmes connus ou non pour résoudre ce problème dans le pire des cas. L algorithme optimal Un algorithme est dit "algorithme optimal" si sa complexité est la complexité minimale parmi les algorithmes de sa classe. Exemple : Algorithme de Horner en O(n) Classes de complexité On distingue deux classes de problèmes : Classe P : Les problèmes faciles à décider, c est à dire de complexité raisonnable (polynomiale). Classe NP : les problèmes faciles à vérifier. Classe P Un problème de classe P est un problème de complexité O(n^k). Faciles à résoudre (pour une valeur k raisonnable). Un problème est dans P s il existe un algorithme pour le résoudre en temps polynômial. Classe NP ( Non-déterministes Polynomiaux ) La classe NP représente l ensemble des problèmes pour lesquels aucun algorithme connu ne peut faire mieux dans le pire cas qu'une complexité exponentielle. Un problème est dans NP s'il existe un algorithme pour vérifier qu'une solution donnée convient, en un temps polynômial. Les problèmes dans NP peuvent être résolus en énumérant l'ensemble des solutions possibles. Exemple : Problème : Factorisation d'un entier N, en un produit de facteurs premiers. On ne sait pas s'il existe un algorithme polynômial pour déterminer les facteurs premiers : p1.p2. pk. Mais, pour des nombres p1,...,pk donnés, il est trivial de vérifier si N=p1.p2. pk. Application La contrainte de complexité d'algorithmique reste la seule barrière contre une cryptanalyse par factorisation. Exemple : Algorithme cryptographique RSA Classe NP-complets (NPC). La classe NPC représente un sous-ensemble de la classe NP, qui contient les problèmes les plus difficiles. Les problèmes de la classe NPC peuvent servir comme des sous-routines pour la résolution des problèmes de la classe NP. Une solution polynomiale à un problème NPC implique une solution polynomiale à tous les problèmes NP. Les problèmes d'optimisation NP-complet ne possèdent pas, à ce jour, un algorithme général permettant de les résoudre en un temps polynomial. Exemples de problèmes NP-complets. Un très large spectre de domaines de recherche : Programmation Linéaire, Théorie des Graphes, Recherche Opérationnelle, Combinatoire, Programmation par Contraintes, etc. Quelques problèmes fondamentaux et stratégiques pour nombre d'applications industrielles : Problème de sac à dos. Voyageur de commerce. Cycle hamiltonien. Clique maximum. Colorations de graphes. ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 19 ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 20

11 Exemple1 : Problème du voyageur de commerce Entrées : un ensemble de villes et une distance d. Question : Existe-il un chemin passant par toutes les villes et de longueur inférieure à d. Nul ne sait résoudre parfaitement ce problème : Complexité en O(n!). Exemple 2: SAT Conclusion : La théorie de la complexité algorithmique s'intéresse à l'estimation de l'efficacité des algorithmes. En générale, on s intéresse aux complexités dans le pire/meilleur des cas. Le calcul de la complexité en moyenne est rare et très délicat. La complexité asymptotique d un algorithme donne un ordre de grandeur du nombre d'opérations élémentaires nécessaires. Connaître les complexités en temps et en espace de différents algorithmes réalisant une même tâche permet de répondre à la question suivante : Quel est le meilleur algorithme et dans quelles conditions. Un algorithme qui n'est pas polynomial ou logarithmique a de grandes chances de ne pas être Calculer la complexité. Approches de résolution des problèmes NP complets. : On conjecture que les problèmes NP-complets ne sont pas solubles en un temps polynomial. À partir de là plusieurs approches sont tentées : Séparation et évaluation (branch and bound) : Analyse du problème et élimination de larges classes de mauvaises solutions. Seules les solutions potentiellement bonnes sont donc énumérées Solutions exactes en un temps modéré. Approximation (heuristiques) Solutions approchées généralement de bonne qualité, mais sans aucune garantie sur l optimalité. Recuit simulé, Algorithmes génétiques, réseaux de neurones, Algorithmes à estimation de distribution, Optimisation par colonie de fourmis. ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 21 ENP /2011/2012/G.I /1 Année / Chap. 3 : Complexité 22