Rappel d'avant-hier. Margaux Nattaf 1 / 22

Transcription

1 Rappel d'avant-hier Margaux Nattaf 1 / 22

2 Rappel d'avant-hier Problématique : On cherche à mesurer l'ecacité d'un algorithme (en temps). Margaux Nattaf 1 / 22

3 Rappel d'avant-hier Problématique : On cherche à mesurer l'ecacité d'un algorithme (en temps). Le temps d'exécution est proportionnel au nombre d'opérations élementaires eectués. Margaux Nattaf 1 / 22

4 Rappel d'avant-hier Problématique : On cherche à mesurer l'ecacité d'un algorithme (en temps). Le temps d'exécution est proportionnel au nombre d'opérations élementaires eectués. Nombre d'opérations dépend de la taille de la donnée Margaux Nattaf 1 / 22

5 Rappel d'avant-hier Problématique : On cherche à mesurer l'ecacité d'un algorithme (en temps). Le temps d'exécution est proportionnel au nombre d'opérations élementaires eectués. Nombre d'opérations dépend de la taille de la donnée et de la diculté de l'instance ; Margaux Nattaf 1 / 22

6 Rappel d'avant-hier Problématique : On cherche à mesurer l'ecacité d'un algorithme (en temps). Le temps d'exécution est proportionnel au nombre d'opérations élementaires eectués. Nombre d'opérations dépend de la taille de la donnée et de la diculté de l'instance ; En général, on mesure la complexité asymptotique et dans le pire cas. Margaux Nattaf 1 / 22

7 Programme d'aujourd'hui Règles de réduction pour O(.) Margaux Nattaf 2 / 22

8 Programme d'aujourd'hui Règles de réduction pour O(.) Technique de calcul de complexité Méthode par substitution Théorème Maître Margaux Nattaf 2 / 22

9 Programme d'aujourd'hui Règles de réduction pour O(.) Technique de calcul de complexité Méthode par substitution Théorème Maître Taille de la donnée Margaux Nattaf 2 / 22

10 Programme d'aujourd'hui Règles de réduction pour O(.) Technique de calcul de complexité Méthode par substitution Théorème Maître Taille de la donnée Classes complexité Algorithmes Polynomiaux Algorithmes Exponnentiels Margaux Nattaf 2 / 22

11 Règles de calculs : combinaisons des complexités Les instructions de base prennent un temps constant, noté O(1) ; Margaux Nattaf 3 / 22

12 Règles de calculs : combinaisons des complexités Les instructions de base prennent un temps constant, noté O(1) ; On additionne les complexités d'opérations en séquence : O(f 1 (n)) + O(f 2 (n)) = O(f 1 (n) + f 2 (n)) Margaux Nattaf 3 / 22

13 Règles de calculs : combinaisons des complexités Les instructions de base prennent un temps constant, noté O(1) ; On additionne les complexités d'opérations en séquence : O(f 1 (n)) + O(f 2 (n)) = O(f 1 (n) + f 2 (n)) Même chose pour les branchements conditionnels : Margaux Nattaf 3 / 22

14 Règles de calculs : combinaisons des complexités Les instructions de base prennent un temps constant, noté O(1) ; On additionne les complexités d'opérations en séquence : O(f 1 (n)) + O(f 2 (n)) = O(f 1 (n) + f 2 (n)) Même chose pour les branchements conditionnels : Exemple si <condition> alors #instructions (1); sinon #instructions (2) ; n Margaux Nattaf 3 / 22

15 Règles de calculs : combinaisons des complexités Les instructions de base prennent un temps constant, noté O(1) ; On additionne les complexités d'opérations en séquence : O(f 1 (n)) + O(f 2 (n)) = O(f 1 (n) + f 2 (n)) Même chose pour les branchements conditionnels : Exemple si <condition> alors #instructions (1); sinon #instructions (2) ; n O(g(n)) Margaux Nattaf 3 / 22

16 Règles de calculs : combinaisons des complexités Les instructions de base prennent un temps constant, noté O(1) ; On additionne les complexités d'opérations en séquence : O(f 1 (n)) + O(f 2 (n)) = O(f 1 (n) + f 2 (n)) Même chose pour les branchements conditionnels : Exemple si <condition> alors #instructions (1); sinon #instructions (2) ; n O(g(n)) O(f 1 (n)) Margaux Nattaf 3 / 22

17 Règles de calculs : combinaisons des complexités Les instructions de base prennent un temps constant, noté O(1) ; On additionne les complexités d'opérations en séquence : O(f 1 (n)) + O(f 2 (n)) = O(f 1 (n) + f 2 (n)) Même chose pour les branchements conditionnels : Exemple si <condition> alors #instructions (1); sinon #instructions (2) ; n O(g(n)) O(f 1 (n)) O(f 2 (n)) Margaux Nattaf 3 / 22

18 Règles de calculs : combinaisons des complexités Les instructions de base prennent un temps constant, noté O(1) ; On additionne les complexités d'opérations en séquence : O(f 1 (n)) + O(f 2 (n)) = O(f 1 (n) + f 2 (n)) Même chose pour les branchements conditionnels : Exemple si <condition> alors #instructions (1); sinon #instructions (2) ; n O(g(n)) O(f 1 (n)) O(f 2 (n)) = O(g(n) + f 1 (n) + f 2 (n)) Margaux Nattaf 3 / 22

19 Règles de calculs : combinaison des complexité Dans les boucles, on multiplie la complexité du corps de la boucle par le nombre d'itérations ; Margaux Nattaf 4 / 22

20 Règles de calculs : combinaison des complexité Dans les boucles, on multiplie la complexité du corps de la boucle par le nombre d'itérations ; La complexité d'une boucle while se calcul comme suit : Exemple en supposant qu'on a m itérations tant que <condition> faire #instructions ; n O(g(n)) O(f (n)) } = O(m (g(n) + f (n))) Margaux Nattaf 4 / 22

21 Règles de calculs : combinaison des complexité Dans les boucles, on multiplie la complexité du corps de la boucle par le nombre d'itérations ; La complexité d'une boucle for se calcul comme suit : Exemple pour i allant de a à b faire #instructions ; n O(f (n)) } = O((b a + 1) f (n)) Margaux Nattaf 4 / 22

22 Calcul de la complexité asymptotique d'un algorithme Pour calculer la complexité d'un algorithme : Margaux Nattaf 5 / 22

23 Calcul de la complexité asymptotique d'un algorithme Pour calculer la complexité d'un algorithme : 1 on calcule la complexité de chaque partie de l'algorithme ; Margaux Nattaf 5 / 22

24 Calcul de la complexité asymptotique d'un algorithme Pour calculer la complexité d'un algorithme : 1 on calcule la complexité de chaque partie de l'algorithme ; 2 on combine ces complexités conformément aux règles qu'on vient de voir ; Margaux Nattaf 5 / 22

25 Calcul de la complexité asymptotique d'un algorithme Pour calculer la complexité d'un algorithme : 1 on calcule la complexité de chaque partie de l'algorithme ; 2 on combine ces complexités conformément aux règles qu'on vient de voir ; 3 on simplie le résultat grâce aux règles de simplications qu'on a vues ; élimination des constantes, et conservation du (des) termes dominants Margaux Nattaf 5 / 22

26 Exemple : calcul de la factorielle de n N Reprenons le calcul de la factorielle, qui nécessitait n opérations : Algorithme : Factorielle(n) Données : un entier n Résultat : un entier valant n! 1 fact, i : entier; 2 début 3 fact := 2; 4 pour i allant de 3 à n faire 5 fact = fact i; 6 n 7 retourner fact; 8 n Margaux Nattaf 6 / 22

27 Exemple : calcul de la factorielle de n N Reprenons le calcul de la factorielle, qui nécessitait n opérations : Algorithme : Factorielle(n) Données : un entier n Résultat : un entier valant n! 1 fact, i : entier; 2 début 3 fact := 2; 4 pour i allant de 3 à n faire 5 fact = fact i; 6 n 7 retourner fact; 8 n L3 initialisation : O(1) Margaux Nattaf 6 / 22

28 Exemple : calcul de la factorielle de n N Reprenons le calcul de la factorielle, qui nécessitait n opérations : Algorithme : Factorielle(n) Données : un entier n Résultat : un entier valant n! 1 fact, i : entier; 2 début 3 fact := 2; 4 pour i allant de 3 à n faire 5 fact = fact i; 6 n 7 retourner fact; 8 n L3 L4 initialisation : O(1) itérations : O(n) Margaux Nattaf 6 / 22

29 Exemple : calcul de la factorielle de n N Reprenons le calcul de la factorielle, qui nécessitait n opérations : Algorithme : Factorielle(n) Données : un entier n Résultat : un entier valant n! 1 fact, i : entier; 2 début 3 fact := 2; 4 pour i allant de 3 à n faire 5 fact = fact i; 6 n 7 retourner fact; 8 n L3 L4 L5 initialisation : O(1) itérations : O(n) multiplication + aectation : O(1) Margaux Nattaf 6 / 22

30 Exemple : calcul de la factorielle de n N Reprenons le calcul de la factorielle, qui nécessitait n opérations : Algorithme : Factorielle(n) Données : un entier n Résultat : un entier valant n! 1 fact, i : entier; 2 début 3 fact := 2; 4 pour i allant de 3 à n faire 5 fact = fact i; 6 n 7 retourner fact; 8 n L3 L4 L5 L7 initialisation : O(1) itérations : O(n) multiplication + aectation : O(1) O(1) Margaux Nattaf 6 / 22

31 Exemple : calcul de la factorielle de n N Reprenons le calcul de la factorielle, qui nécessitait n opérations : Algorithme : Factorielle(n) Données : un entier n Résultat : un entier valant n! 1 fact, i : entier; 2 début 3 fact := 2; 4 pour i allant de 3 à n faire 5 fact = fact i; 6 n 7 retourner fact; 8 n L3 L4 L5 L7 initialisation : O(1) itérations : O(n) multiplication + aectation : O(1) O(1) Nombre total d'opérations : O(1) + O(n) O(1) + O(1) = O(n) Margaux Nattaf 6 / 22

32 Récurrences Algorithme : TriFusion(T) Données : un tableau T Résultat : le tableau T trié mil : entier; début si T 1 alors retourner T ; n sinon T +1 milieu := ; 2 retourner Fusion(T [1..mil], T [mil.. T ]); n n Margaux Nattaf 7 / 22

33 Récurrences Algorithme : TriFusion(T) Données : un tableau T Résultat : le tableau T trié mil : entier; début si T 1 alors retourner T ; n sinon T +1 milieu := ; 2 retourner Fusion(T [1..mil], T [mil.. T ]); n n Algorithme : Fusion(T1,T2) Données : deux tableaux T 1 et T 2 Résultat : un tableau T trié contenant les éléments de T 1 et de T 2 T : tableau de taille T 1 + T 2; début si T 1 = 0 alors T = T 2; sinon si T 2 = 0 alors T = T 1; sinon si T 1[1] < T 2[1] alors T [1] = T 1[1]; T [2.. T ] = Fusion(T 1[2.. T 1, T 2[1.. T 2 ]); sinon T [1] = T 2[1]; T [2.. T ] = Fusion(T 1[1.. T 1, T 2[2.. T 2 ]); n retourner T n Margaux Nattaf 7 / 22

34 Illustration du Tri Fusion Margaux Nattaf 8 / 22

35 Récurrences Temps d'exécution T dans le pire des cas du tri fusion pour trier un tableau de n entiers Margaux Nattaf 9 / 22

36 Récurrences Temps d'exécution T dans le pire des cas du tri fusion pour trier un tableau de n entiers T (n) = { Θ(1) si n = 1 2T (n/2) + Θ(n) si n > 1 Margaux Nattaf 9 / 22

37 Récurrences Temps d'exécution T dans le pire des cas du tri fusion pour trier un tableau de n entiers T (n) = { Θ(1) si n = 1 2T (n/2) + Θ(n) si n > 1 Complexité du tri fusion : T (n) = Θ(n log n) Margaux Nattaf 9 / 22

38 Récurrences Temps d'exécution T dans le pire des cas du tri fusion pour trier un tableau de n entiers T (n) = { Θ(1) si n = 1 2T (n/2) + Θ(n) si n > 1 Complexité du tri fusion : T (n) = Θ(n log n) Comment passer de l'un à l'autre? Méthode par substitution Méthode générale (théorème maître) Margaux Nattaf 9 / 22

39 Méthode par substitution Il faut avoir une intuition sur la forme de la solution (ici : O(n log n)) Margaux Nattaf 10 / 22

40 Méthode par substitution Il faut avoir une intuition sur la forme de la solution (ici : O(n log n)) Permet de borner une récurrence soit par excès, soit par défaut (par en haut ou par en bas) Margaux Nattaf 10 / 22

41 Méthode par substitution Il faut avoir une intuition sur la forme de la solution (ici : O(n log n)) Permet de borner une récurrence soit par excès, soit par défaut (par en haut ou par en bas) On va montrer qu'il existe c > 0 t.q. T (n) = 2T ( n/2 ) + n cn log n Margaux Nattaf 10 / 22

42 Méthode par substitution Il faut avoir une intuition sur la forme de la solution (ici : O(n log n)) Permet de borner une récurrence soit par excès, soit par défaut (par en haut ou par en bas) On va montrer qu'il existe c > 0 t.q. T (n) = 2T ( n/2 ) + n cn log n On procède par induction ( récurrence) Margaux Nattaf 10 / 22

43 Méthode par substitution (I) T (n) = 2T ( n/2 ) + n cn log n Il faut montrer que la formule est vraie pour les conditions limites de la récurrence pour des données de petite taille, i.e. n = 1 ou 2 en générale Margaux Nattaf 11 / 22

44 Méthode par substitution (I) T (n) = 2T ( n/2 ) + n cn log n Il faut montrer que la formule est vraie pour les conditions limites de la récurrence pour des données de petite taille, i.e. n = 1 ou 2 en générale Problème : c'est faux pour n = 1 car c1 log 1 = 0 ne peut être < T (1) ; Margaux Nattaf 11 / 22

45 Méthode par substitution (I) T (n) = 2T ( n/2 ) + n cn log n Il faut montrer que la formule est vraie pour les conditions limites de la récurrence pour des données de petite taille, i.e. n = 1 ou 2 en générale Problème : c'est faux pour n = 1 car c1 log 1 = 0 ne peut être < T (1) ; Mais on cherche à montrer la complexité pour des tailles supérieures ou égale n 0 pour de grande valeur de n... Margaux Nattaf 11 / 22

46 Méthode par substitution (I) T (n) = 2T ( n/2 ) + n cn log n Il faut montrer que la formule est vraie pour les conditions limites de la récurrence pour des données de petite taille, i.e. n = 1 ou 2 en générale Problème : c'est faux pour n = 1 car c1 log 1 = 0 ne peut être < T (1) ; Mais on cherche à montrer la complexité pour des tailles supérieures ou égale n 0 pour de grande valeur de n... On utilise n 0 = 2 et on vérie que la formule tient pour T (2) et T (3) (car ce sont les deux valeurs qui dépendent de T (1)). Margaux Nattaf 11 / 22

47 Méthode par substitution (II) T (n) = 2T ( n/2 ) + n cn log n On vérie que la formule tient pour T (2) et T (3) Margaux Nattaf 12 / 22

48 Méthode par substitution (II) T (n) = 2T ( n/2 ) + n cn log n On vérie que la formule tient pour T (2) et T (3) T (2) = 2T ( 2/2 ) + 2 Margaux Nattaf 12 / 22

49 Méthode par substitution (II) T (n) = 2T ( n/2 ) + n cn log n On vérie que la formule tient pour T (2) et T (3) T (2) = 2T ( 2/2 ) + 2 T (2) = 2T (1) + 2 Margaux Nattaf 12 / 22

50 Méthode par substitution (II) T (n) = 2T ( n/2 ) + n cn log n On vérie que la formule tient pour T (2) et T (3) T (2) = 2T ( 2/2 ) + 2 T (2) = 2T (1) + 2 T (2) = = 1 2c log 2 = 2c Margaux Nattaf 12 / 22

51 Méthode par substitution (II) T (n) = 2T ( n/2 ) + n cn log n On vérie que la formule tient pour T (2) et T (3) T (2) = 2T ( 2/2 ) + 2 T (2) = 2T (1) + 2 T (2) = = 1 2c log 2 = 2c T (2) = 1 2c log 2 = 2c Margaux Nattaf 12 / 22

52 Méthode par substitution (II) T (n) = 2T ( n/2 ) + n cn log n On vérie que la formule tient pour T (2) et T (3) T (2) = 2T ( 2/2 ) + 2 T (2) = 2T (1) + 2 T (2) = = 1 2c log 2 = 2c T (2) = 1 2c log 2 = 2c On fait la même chose pour T (3)... Margaux Nattaf 12 / 22

53 Méthode par substitution (II) T (n) = 2T ( n/2 ) + n cn log n On vérie que la formule tient pour T (2) et T (3) T (2) = 2T ( 2/2 ) + 2 T (2) = 2T (1) + 2 T (2) = = 1 2c log 2 = 2c T (2) = 1 2c log 2 = 2c On fait la même chose pour T (3) et on obtient que c doit être 2. Margaux Nattaf 12 / 22

54 Méthode par substitution (III) T (n) = 2T ( n/2 ) + n cn log n On suppose maintenant que c'est vrai pour T ( n/2 ) T ( n/2 ) c n/2 log n/2 Margaux Nattaf 13 / 22

55 Méthode par substitution (III) T (n) = 2T ( n/2 ) + n cn log n On suppose maintenant que c'est vrai pour T ( n/2 ) T ( n/2 ) c n/2 log n/2 On substitue dans l'expression T (n) = 2T ( n/2 ) + n Margaux Nattaf 13 / 22

56 Méthode par substitution (III) T (n) = 2T ( n/2 ) + n cn log n On suppose maintenant que c'est vrai pour T ( n/2 ) On substitue dans l'expression T ( n/2 ) c n/2 log n/2 T (n) = 2T ( n/2 ) + n 2c n log( n ) n Margaux Nattaf 13 / 22

57 Méthode par substitution (III) T (n) = 2T ( n/2 ) + n cn log n On suppose maintenant que c'est vrai pour T ( n/2 ) T ( n/2 ) c n/2 log n/2 On substitue dans l'expression T (n) = 2T ( n/2 ) + n 2c n log( n ) n cn log(n/2) + n Margaux Nattaf 13 / 22

58 Méthode par substitution (III) T (n) = 2T ( n/2 ) + n cn log n On suppose maintenant que c'est vrai pour T ( n/2 ) T ( n/2 ) c n/2 log n/2 On substitue dans l'expression T (n) = 2T ( n/2 ) + n 2c n log( n ) n cn log(n/2) + n cn log n cn log 2 + n Margaux Nattaf 13 / 22

59 Méthode par substitution (III) T (n) = 2T ( n/2 ) + n cn log n On suppose maintenant que c'est vrai pour T ( n/2 ) T ( n/2 ) c n/2 log n/2 On substitue dans l'expression T (n) = 2T ( n/2 ) + n 2c n log( n ) n cn log(n/2) + n cn log n cn log 2 + n cn log n cn + n Margaux Nattaf 13 / 22

60 Méthode par substitution (III) T (n) = 2T ( n/2 ) + n cn log n On suppose maintenant que c'est vrai pour T ( n/2 ) T ( n/2 ) c n/2 log n/2 On substitue dans l'expression T (n) = 2T ( n/2 ) + n 2c n log( n ) n cn log(n/2) + n cn log n cn log 2 + n cn log n cn + n cn log n Margaux Nattaf 13 / 22

61 Méthode par substitution (III) T (n) = 2T ( n/2 ) + n cn log n On suppose maintenant que c'est vrai pour T ( n/2 ) T ( n/2 ) c n/2 log n/2 On substitue dans l'expression T (n) = 2T ( n/2 ) + n 2c n log( n ) n cn log(n/2) + n cn log n cn log 2 + n cn log n cn + n cn log n A condition que c 1 (on prendra c 2, à cause de T (2) et T (3)) Margaux Nattaf 13 / 22

62 Méthode générale Pour les récurrence de la forme T (n) = at (n/b) + f (n) avec a 1 et b > 1 Margaux Nattaf 14 / 22

63 Méthode générale Pour les récurrence de la forme T (n) = at (n/b) + f (n) avec a 1 et b > 1 L'algorithme découpe la donnée en a sous-problèmes de taille n/b et les résout récursivement La fonction f représente le coût de division et de fusion du problème. Margaux Nattaf 14 / 22

64 Méthode générale Pour les récurrence de la forme T (n) = at (n/b) + f (n) avec a 1 et b > 1 L'algorithme découpe la donnée en a sous-problèmes de taille n/b et les résout récursivement La fonction f représente le coût de division et de fusion du problème. Exemple pour le tri fusion : a = 2, b = 2 et f (n) = Θ(n) Margaux Nattaf 14 / 22

65 Méthode générale Pour les récurrence de la forme T (n) = at (n/b) + f (n) avec a 1 et b > 1 L'algorithme découpe la donnée en a sous-problèmes de taille n/b et les résout récursivement La fonction f représente le coût de division et de fusion du problème. Exemple pour le tri fusion : a = 2, b = 2 et f (n) = Θ(n) On peut omettre ici les parties entières ( n/b ou n/b ) Margaux Nattaf 14 / 22

66 Méthode générale Pour les récurrence de la forme T (n) = at (n/b) + f (n) avec a 1 et b > 1 L'algorithme découpe la donnée en a sous-problèmes de taille n/b et les résout récursivement La fonction f représente le coût de division et de fusion du problème. Exemple pour le tri fusion : a = 2, b = 2 et f (n) = Θ(n) On peut omettre ici les parties entières ( n/b ou n/b ) Il existe un théorème pour identié la complexité : le théorème maître Margaux Nattaf 14 / 22

67 Théorème maître (général) - version simpliée On ne considère que les récurrences T (n) = at (n/b) + O(n d ) avec a 1, b > 1, d 0 Margaux Nattaf 15 / 22

68 Théorème maître (général) - version simpliée On ne considère que les récurrences T (n) = at (n/b) + O(n d ) avec a 1, b > 1, d 0 1 Si d > log b a, T (n) = Θ(n d ) 2 Si d = log b a, T (n) = Θ(n d log n) 3 Si d < log b a, T (n) = Θ(n log b a ) Margaux Nattaf 15 / 22

69 Théorème maître (général) - version simpliée On ne considère que les récurrences T (n) = at (n/b) + O(n d ) avec a 1, b > 1, d 0 1 Si d > log b a, T (n) = Θ(n d ) 2 Si d = log b a, T (n) = Θ(n d log n) 3 Si d < log b a, T (n) = Θ(n log b a ) Tri fusion : T (n) = { Θ(1) si n = 1 2T (n/2) + Θ(n) si n > 1 Margaux Nattaf 15 / 22

70 Théorème maître (général) - version simpliée On ne considère que les récurrences T (n) = at (n/b) + O(n d ) avec a 1, b > 1, d 0 1 Si d > log b a, T (n) = Θ(n d ) 2 Si d = log b a, T (n) = Θ(n d log n) 3 Si d < log b a, T (n) = Θ(n log b a ) Tri fusion : T (n) = { Θ(1) si n = 1 2T (n/2) + Θ(n) si n > 1 a = 2, Margaux Nattaf 15 / 22

71 Théorème maître (général) - version simpliée On ne considère que les récurrences T (n) = at (n/b) + O(n d ) avec a 1, b > 1, d 0 1 Si d > log b a, T (n) = Θ(n d ) 2 Si d = log b a, T (n) = Θ(n d log n) 3 Si d < log b a, T (n) = Θ(n log b a ) Tri fusion : T (n) = { Θ(1) si n = 1 2T (n/2) + Θ(n) si n > 1 a = 2, b = 2, Margaux Nattaf 15 / 22

72 Théorème maître (général) - version simpliée On ne considère que les récurrences T (n) = at (n/b) + O(n d ) avec a 1, b > 1, d 0 1 Si d > log b a, T (n) = Θ(n d ) 2 Si d = log b a, T (n) = Θ(n d log n) 3 Si d < log b a, T (n) = Θ(n log b a ) Tri fusion : T (n) = { Θ(1) si n = 1 2T (n/2) + Θ(n) si n > 1 a = 2, b = 2, d = 1, Margaux Nattaf 15 / 22

73 Théorème maître (général) - version simpliée On ne considère que les récurrences T (n) = at (n/b) + O(n d ) avec a 1, b > 1, d 0 1 Si d > log b a, T (n) = Θ(n d ) 2 Si d = log b a, T (n) = Θ(n d log n) 3 Si d < log b a, T (n) = Θ(n log b a ) Tri fusion : T (n) = { Θ(1) si n = 1 2T (n/2) + Θ(n) si n > 1 a = 2, b = 2, d = 1, log 2 2 = 1 = d Margaux Nattaf 15 / 22

74 Théorème maître (général) - version simpliée On ne considère que les récurrences T (n) = at (n/b) + O(n d ) avec a 1, b > 1, d 0 1 Si d > log b a, T (n) = Θ(n d ) 2 Si d = log b a, T (n) = Θ(n d log n) 3 Si d < log b a, T (n) = Θ(n log b a ) Tri fusion : T (n) = { Θ(1) si n = 1 2T (n/2) + Θ(n) si n > 1 a = 2, b = 2, d = 1, log 2 2 = 1 = d On est donc dans le cas 2 et la complexité en Θ(n log n) Margaux Nattaf 15 / 22

75 La taille de la donnée La taille des données va dépendre de leur codage ; Margaux Nattaf 16 / 22

76 La taille de la donnée La taille des données va dépendre de leur codage ; On choisit comme taille la ou les dimensions les plus signicatives ; Margaux Nattaf 16 / 22

77 La taille de la donnée La taille des données va dépendre de leur codage ; On choisit comme taille la ou les dimensions les plus signicatives ; Exemple En fonction du problème, les entrées et leur taille peuvent être : Margaux Nattaf 16 / 22

78 La taille de la donnée La taille des données va dépendre de leur codage ; On choisit comme taille la ou les dimensions les plus signicatives ; Exemple En fonction du problème, les entrées et leur taille peuvent être : des éléments : le nombre d'éléments ; Margaux Nattaf 16 / 22

79 La taille de la donnée La taille des données va dépendre de leur codage ; On choisit comme taille la ou les dimensions les plus signicatives ; Exemple En fonction du problème, les entrées et leur taille peuvent être : des éléments : le nombre d'éléments ; des nombres : nombre de bits nécessaires à leur représentation (log 2 (n)) ; Margaux Nattaf 16 / 22

80 La taille de la donnée La taille des données va dépendre de leur codage ; On choisit comme taille la ou les dimensions les plus signicatives ; Exemple En fonction du problème, les entrées et leur taille peuvent être : des éléments : le nombre d'éléments ; des nombres : nombre de bits nécessaires à leur représentation (log 2 (n)) ; des matrices : taille m n max(m, n), m.n, m + n ; Margaux Nattaf 16 / 22

81 La taille de la donnée La taille des données va dépendre de leur codage ; On choisit comme taille la ou les dimensions les plus signicatives ; Exemple En fonction du problème, les entrées et leur taille peuvent être : des éléments : le nombre d'éléments ; des nombres : nombre de bits nécessaires à leur représentation (log 2 (n)) ; des matrices : taille m n max(m, n), m.n, m + n ; des graphes : nombre de sommets, nombre d'arcs, produit des deux ; Margaux Nattaf 16 / 22

82 La taille de la donnée La taille des données va dépendre de leur codage ; On choisit comme taille la ou les dimensions les plus signicatives ; Exemple En fonction du problème, les entrées et leur taille peuvent être : des éléments : le nombre d'éléments ; des nombres : nombre de bits nécessaires à leur représentation (log 2 (n)) ; des matrices : taille m n max(m, n), m.n, m + n ; des graphes : nombre de sommets, nombre d'arcs, produit des deux ; des tableaux : (ou listes) nombre de cases, d'éléments ; Margaux Nattaf 16 / 22

83 La taille de la donnée La taille des données va dépendre de leur codage ; On choisit comme taille la ou les dimensions les plus signicatives ; Exemple En fonction du problème, les entrées et leur taille peuvent être : des éléments : le nombre d'éléments ; des nombres : nombre de bits nécessaires à leur représentation (log 2 (n)) ; des matrices : taille m n max(m, n), m.n, m + n ; des graphes : nombre de sommets, nombre d'arcs, produit des deux ; des tableaux : (ou listes) nombre de cases, d'éléments ; des mots : leur longueur. Margaux Nattaf 16 / 22

84 Vocabulaire Un algorithme est dit : Margaux Nattaf 17 / 22

85 Vocabulaire Un algorithme est dit : en temps constant si sa complexité (dans le pire des cas) est bornée par une constante Margaux Nattaf 17 / 22

86 Vocabulaire Un algorithme est dit : en temps constant si sa complexité (dans le pire des cas) est bornée par une constante linéaire (resp. linéairement borné) si sa complexité (dans le pire des cas) est Θ(n) (resp. O(n)) Margaux Nattaf 17 / 22

87 Vocabulaire Un algorithme est dit : en temps constant si sa complexité (dans le pire des cas) est bornée par une constante linéaire (resp. linéairement borné) si sa complexité (dans le pire des cas) est Θ(n) (resp. O(n)) quadratique (resp. au plus quadratique) si sa complexité (dans le pire des cas) est Θ(n 2 ) (resp. O(n 2 )) Margaux Nattaf 17 / 22

88 Vocabulaire Un algorithme est dit : en temps constant si sa complexité (dans le pire des cas) est bornée par une constante linéaire (resp. linéairement borné) si sa complexité (dans le pire des cas) est Θ(n) (resp. O(n)) quadratique (resp. au plus quadratique) si sa complexité (dans le pire des cas) est Θ(n 2 ) (resp. O(n 2 )) polynômial ou polynômialement borné, si sa complexité (dans le pire des cas) est en O(n p ) pour un certain p > 0 (Q : n log n?) Margaux Nattaf 17 / 22

89 Vocabulaire Un algorithme est dit : en temps constant si sa complexité (dans le pire des cas) est bornée par une constante linéaire (resp. linéairement borné) si sa complexité (dans le pire des cas) est Θ(n) (resp. O(n)) quadratique (resp. au plus quadratique) si sa complexité (dans le pire des cas) est Θ(n 2 ) (resp. O(n 2 )) polynômial ou polynômialement borné, si sa complexité (dans le pire des cas) est en O(n p ) pour un certain p > 0 (Q : n log n?) (au plus) exponentiel si elle est en O(2 np ) pour un certain p > 0 Margaux Nattaf 17 / 22

90 Hiérarchie Pour faire un choix éclairé entre plusieurs algorithmes, il faut être capable de situer leur complexité ; Margaux Nattaf 18 / 22

91 Hiérarchie Pour faire un choix éclairé entre plusieurs algorithmes, il faut être capable de situer leur complexité ; On fait une première distinction entre les deux classes suivantes : Margaux Nattaf 18 / 22

92 Hiérarchie Pour faire un choix éclairé entre plusieurs algorithmes, il faut être capable de situer leur complexité ; On fait une première distinction entre les deux classes suivantes : 1 les algorithmes dits polynomiaux, dont la complexité est en O(n k ) pour un certain k ; Margaux Nattaf 18 / 22

93 Hiérarchie Pour faire un choix éclairé entre plusieurs algorithmes, il faut être capable de situer leur complexité ; On fait une première distinction entre les deux classes suivantes : 1 les algorithmes dits polynomiaux, dont la complexité est en O(n k ) pour un certain k ; 2 les algorithmes dits exponentiels, dont la complexité ne peut pas être majorée par une fonction polynomiale ; Margaux Nattaf 18 / 22

94 Hiérarchie Pour faire un choix éclairé entre plusieurs algorithmes, il faut être capable de situer leur complexité ; On fait une première distinction entre les deux classes suivantes : 1 les algorithmes dits polynomiaux, dont la complexité est en O(n k ) pour un certain k ; 2 les algorithmes dits exponentiels, dont la complexité ne peut pas être majorée par une fonction polynomiale ; De même : Margaux Nattaf 18 / 22

95 Hiérarchie Pour faire un choix éclairé entre plusieurs algorithmes, il faut être capable de situer leur complexité ; On fait une première distinction entre les deux classes suivantes : 1 les algorithmes dits polynomiaux, dont la complexité est en O(n k ) pour un certain k ; 2 les algorithmes dits exponentiels, dont la complexité ne peut pas être majorée par une fonction polynomiale ; De même : 1 un problème de complexité polynomiale est considéré facile ; Margaux Nattaf 18 / 22

96 Hiérarchie Pour faire un choix éclairé entre plusieurs algorithmes, il faut être capable de situer leur complexité ; On fait une première distinction entre les deux classes suivantes : 1 les algorithmes dits polynomiaux, dont la complexité est en O(n k ) pour un certain k ; 2 les algorithmes dits exponentiels, dont la complexité ne peut pas être majorée par une fonction polynomiale ; De même : 1 un problème de complexité polynomiale est considéré facile ; 2 sinon (complexité non-polynomiale ou inconnue (!)) il est considéré dicile ; Margaux Nattaf 18 / 22

97 Hiérarchie Pour faire un choix éclairé entre plusieurs algorithmes, il faut être capable de situer leur complexité ; On fait une première distinction entre les deux classes suivantes : 1 les algorithmes dits polynomiaux, dont la complexité est en O(n k ) pour un certain k ; 2 les algorithmes dits exponentiels, dont la complexité ne peut pas être majorée par une fonction polynomiale ; De même : 1 un problème de complexité polynomiale est considéré facile ; 2 sinon (complexité non-polynomiale ou inconnue (!)) il est considéré dicile ; Margaux Nattaf 18 / 22

98 Hiérarchie De même : 1 un problème de complexité polynomiale est considéré facile ; 2 sinon (complexité non-polynomiale ou inconnue (!)) il est considéré dicile ; Attention! Margaux Nattaf 19 / 22

99 Hiérarchie De même : 1 un problème de complexité polynomiale est considéré facile ; 2 sinon (complexité non-polynomiale ou inconnue (!)) il est considéré dicile ; Attention! 1 Attention à la puissance du polynôme : n 5 30 ans si n = Margaux Nattaf 19 / 22

100 Hiérarchie De même : 1 un problème de complexité polynomiale est considéré facile ; 2 sinon (complexité non-polynomiale ou inconnue (!)) il est considéré dicile ; Attention! 1 Attention à la puissance du polynôme : n 5 30 ans si n = Un algorithme peut avoir un comportement mauvais dans le pire des cas mais être ecace en général (exemple : algorithme du simplexe) Margaux Nattaf 19 / 22

101 Hiérarchie De même : 1 un problème de complexité polynomiale est considéré facile ; 2 sinon (complexité non-polynomiale ou inconnue (!)) il est considéré dicile ; Attention! 1 Attention à la puissance du polynôme : n 5 30 ans si n = Un algorithme peut avoir un comportement mauvais dans le pire des cas mais être ecace en général (exemple : algorithme du simplexe) Mais quel est l'intérêt de la classication des problèmes? Margaux Nattaf 19 / 22

102 Sommations Linéarité n (ca k + b k ) = c n a k + n k=1 k=1 k=1 n n Θ(f (k)) = Θ( f (k)) k=1 k=1 b k Séries arithmétiques n k = n = 1 2 n(n + 1) = Θ(n2 ) k=1 Margaux Nattaf 20 / 22

103 Sommations Séries géométriques n x k = 1 + x + x x n = x n+1 1 k=0 x 1 Séries harmoniques n e nombre harmonique H n = n = 1 n k k=1 = ln n + O(1) Margaux Nattaf 21 / 22