analyse dalgorithmes algorithme input output un algorithme est une procédure étape par étape pour...
TRANSCRIPT
![Page 1: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/1.jpg)
Analyse d’Algorithmes
AlgorithmeInput Output
Un algorithme est une procédure étape par étapepour résoudre un problème dans un temps fini.
Structures de donnéesIFT-2000
![Page 2: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/2.jpg)
Temps d’exécution Les algorithmes transforment des objets en entrée en des objets en sortie.Le temps d’exécution d’un algorithme croît en fonction de la taille des entrées.Le temps d’exécution en moyenne est souvent difficile à déterminer. Nous nous intéresserons au pire cas dans le temps d’exécution.
Facile à analyser Crucial dans les applications
dans le domaine des jeux, des finances et de la robotique par exemple.
0
20
40
60
80
100
120
Runnin
g T
ime
1000 2000 3000 4000
Input Size
best caseaverage caseworst case
![Page 3: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/3.jpg)
Études Expérimentales
Écrire un programme implémentant un algorithmeExécuter le programme avec différentes tailles des données en entrée.Utiliser une fonction, comme la fonction prédéfinie clock(), pour avoir une mesure des temps d’exécution.Tracer les résultats.
0
1000
2000
3000
4000
5000
6000
7000
8000
9000
0 50 100
Input Size
Tim
e (
ms)
![Page 4: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/4.jpg)
Limitation des expériences
Il est nécessaire d’implémenter l’algorithme, ce qui peut être difficile.Les résultats peuvent ne pas être indicatifs du temps d’exécution d’autres entrées non inlcuses dans l’expérience. Pour comparer deux algorithmes, le même environnement de programmation (matériel et logiciel) doit être utilisé.
![Page 5: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/5.jpg)
Analyse théorique
Utiliser une description de haut niveau de l’algorithme au lieu de l’implémenter.Caracteriser le temps d’exécution comme une fonction de la taille des entrées, n.Tenir compte de toutes les possibilités comme entrée.Nous permet d’évaluer la vitesse d’un algorithme independemment de l’environnement.
![Page 6: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/6.jpg)
Pseudocode description haut niveau de l’algorithmePlus structuré qu’une prose en français!Moins detaillé qu’un programme Algorithme arrayMax(A, n)
Input tableau A de n entiersOutput l’élément maximum de
A
currentMax A[0]for i 1 to n 1 do
if A[i] currentMax thencurrentMax A[i]
return currentMax
Exemple: trouver l’élément max dans un tableau
![Page 7: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/7.jpg)
Pseudocode
Structures de contrôle if … then … [else …] while … do … repeat … until … for … do … L’indentation remplace les
accolades
Declaration d’une méthodeAlgorithme method (arg [,
arg…])Input …Output …
Appel Methode/Fonction var.method (arg [, arg…])
Valeur retournéereturn expression
Expressions Assignation
(comme en C, C++, Java)
Test d’égalité(comme en C, C++, Java)
n2Exposant et autres formats mathématiques permis
![Page 8: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/8.jpg)
Le modèle “Random Access Machine” (RAM)
Le CPU
Une banque de cellules de mémoire illimitée, chacune peut contenir un nombre arbitraire de caractères
01
2
Les cellules de mémoire sont adressables, leur accès prend une unité de temps
![Page 9: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/9.jpg)
Operations primitives
Instructions de base exécutées par un algorithmeOnt leur correspondant en pseudocodeIndependants d’un langage de programmation Leurs définitions exactes ne sont pas importantes On considère qu’elles prennent un temps constant dans le modèle RAM
Exemples: Evaluation d’une
expression Assigner une valeur à
une variable Indexation dans un
tableau Appeler une methode Retourner d’une
méthode
![Page 10: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/10.jpg)
Compter les opérations primitives
En inspectant le pseudocode, nous pouvons determiner le nombre maximum d’opérations primitives exécutées par l’algorithme, comme une fonction de la taille des entrées
Algorithme arrayMax(A, n)
# operations
currentMax A[0] 2for i 1 to n 1 do 2 + n
if A[i] currentMax then 2(n 1)currentMax A[i] 2(n 1)
{ incrémenter le compteur i } 2(n 1)return currentMax 1
Total 7n 1
![Page 11: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/11.jpg)
Estimation du temps d’exécution
L’algorithme arrayMax exécute 7n 1 opérations primitives dans le pire cas.
Définissons:a = le temps que prend par la plus rapide des opérations primitives b = le temps que prend la plus lente des opérations primitives
Soit T(n) le temps dans le pire cas de arrayMax. On peut alors écrire :
a (7n 1) T(n) b(7n 1)
Ainsi, le temps d’exécution T(n) est bornée par deux fonctions linéaires
![Page 12: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/12.jpg)
Taux de croissance du temps d’exécution
Changer l’environnement (matériel/logiciel) Affecte T(n) par un facteur constant, mais Ne doit pas altérer le taux de croissance de T(n)
Le taux de croissance linéaire du temps d’exécution T(n) est une propriété intrinsèque de l’algorithme arrayMax
![Page 13: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/13.jpg)
Taux de croissance
Taux de croissance des fonctions:
Linéaire n Quadratique n2
Cubique n3
Dans le diagramme log-log, la pente d’une droite correspond au taux de croissance de la fonction.
1E+01E+21E+41E+61E+8
1E+101E+121E+141E+161E+181E+201E+221E+241E+261E+281E+30
1E+0 1E+2 1E+4 1E+6 1E+8 1E+10n
T(n)
Cubic
Quadratic
Linear
![Page 14: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/14.jpg)
Facteurs constants
Le taux de croissance n’est pas affecté par
facteurs constants ou des termes de plus
bas ordres
Exemples 102n + 105 est une
fonction linéaire 105n2 + 108n est une
fonction quadratique 1E+01E+21E+41E+61E+8
1E+101E+121E+141E+161E+181E+201E+221E+241E+26
1E+0 1E+2 1E+4 1E+6 1E+8 1E+10n
T(n)
Quadratique
Quadratique
Linéaire
Linéaire
![Page 15: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/15.jpg)
Notation “Grand-Oh” Soit les fonctions f(n) et g(n), nous dirons que f(n) est en O(g(n)) s’ils existent c et n0, des constantes positives, tel quef(n) cg(n) pour n n0
Exemple: 2n + 10 est en O(n)
2n + 10 cn (c 2) n 10 n 10/(c 2) prendre c = 3 and n0 =
10
1
10
100
1,000
10,000
1 10 100 1,000n
3n
2n+10
n
![Page 16: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/16.jpg)
Exemple “Grand-Oh”
Exemple: la function n2 n’est pas en O(n)
n2 cn n c Les 2 inégalités ne
peuvent être satisfaites si c doit être une constante
1
10
100
1,000
10,000
100,000
1,000,000
1 10 100 1,000n
n^2
100n
10n
n
![Page 17: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/17.jpg)
Autres Exemples “Grand-Oh”
7n-2
7n-2 est en O(n)besoin de c > 0 and n0 1 tel que 7n-2 c•n pour n n0,
Ceci est vrai pour c = 7 et n0 = 1
3n3 + 20n2 + 5
3n3 + 20n2 + 5 is O(n3)besoin de c > 0 et n0 1 tel que 3n3 + 20n2 + 5 c•n3 pour n
n0,
ceci est vrai pour c = 4 et n0 = 21 3 log n + log log n
3 log n + log log n is O(log n)besoin de c > 0 et n0 1 tel que 3 log n + log log n c•log n pour n
n0,
ceci est vrai pour c = 4 et n0 = 2
![Page 18: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/18.jpg)
“Grand-Oh” et le taux de croissance
La notation “big-Oh” donne une borne supérieure au taux de croissance de la fonctionDire que “f(n) est en O(g(n))” signifie que le taux de croissance de f(n) n’est pas supérieur que le taux de croissance de g(n)Nous pouvons utiliser la notation “big-Oh” pour comparer des fonctions par rapport à leur taux de croissance
f(n) is O(g(n)) g(n) is O(f(n))
g(n) croît plus Oui Non
f(n) croît plus Non Oui
Même croissance Oui Oui
![Page 19: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/19.jpg)
Règles du “Grand-
Oh”
Si f(n) est un polynôme de degrés d, f(n) est alors en O(nd), i.e.,
1. négliger les termes de plus bas degrés2. négliger les coefficients constants
Utiliser la petite possible classe de fonctions Dire “2n est en O(n)” au lieu de “2n est en O(n2)”
Utiliser la plus simple expression de la classe Dire “3n + 5 est en O(n)” au lieu de “3n + est en O(3n)”
![Page 20: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/20.jpg)
Analyse asymptotiqueL’analyse asymptotique d’un algorithme determine le temps d’exécution dans la notation ”big-Oh”Pour appliquer l’analyse asymptotique
Il faut trouver le nombre d’opérations primitives exécutées dans le pire cas en focntion de la taille des entrées
Exprimer par la suite cette fonctiond ans la notation “big-Oh”
Exemple: Nous avons determiné que l’algorithme arrayMax
execute au plus 7n 1 operations primitives Nous dirons que l’algorithme arrayMax “s’exécute en un
temps O(n) ”Depuis que les facteurs constants et les termes de plus bas ordres sont négligés, nous pouvons les négliger également lorsque nous compterons les opérations primitives
![Page 21: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/21.jpg)
Calcul des moyennes de prefix
Nous allons illustrer l’anlayse asymptotique avec deux algorithmes pour le calucl des moyennes de prefix La i-ème moyenne prefix d’un tableau X est la moyenne des (i + 1) premiers éléments de X:
A[i] = (X[0] + X[1] + … + X[i])/(i+1)
Calculer le tableau A des moyennes prefix d’un autre tableau X a des applications dans l’analyse financière
0
5
10
15
20
25
30
35
1 2 3 4 5 6 7
X
A
![Page 22: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/22.jpg)
Moyennes prefix (Quadratique)
L’algorithme suivant calcule les moyennes prefix en un temps quadratique en appliquant la definition
Algorithm prefixAverages1(X, n)Input tabelau X de n entiersOutput tableau A des moyennes prefix de X #opérations A nouveau tableau de n entiers nfor i 0 to n 1 do n
s X[0] nfor j 1 to i do 1 + 2 + …+ (n
1)s s + X[j] 1 + 2 + …+ (n
1)A[i] s / (i + 1) n
return A 1
![Page 23: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/23.jpg)
Progression arithmétique
Le temps de calcul de prefixAverages1 est O(1 2 …n)
La somme des n premiers entier est n(n 1) 2
Voici une simple preuve visuelle
Ainsi, l’algorithme prefixAverages1 s’exécute en un temps de l’ordre O(n2)
0
1
2
3
4
5
6
7
1 2 3 4 5 6
![Page 24: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/24.jpg)
Moyennes prefix (Linéaire)
L’algorithme suivant calcule les moyennes prefix en un temps linéaire en considérant les sommes courantes
Algorithm prefixAverages2(X, n)Input tableau X de n entiersOutput tableau A des moyennes prefix de X
#opérationsA nouveau tableau of n entiers ns 0 1for i 0 to n 1 do n
s s + X[i] nA[i] s / (i + 1) n
return A 1L’algorithme prefixAverages2 s’exécute en un temps en O(n)
![Page 25: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/25.jpg)
propriétés des logarithmes:logb(xy) = logbx + logby
logb (x/y) = logbx - logby
logbxa = alogbx
logba = logxa/logxbpropriétés des exponentiels:a(b+c) = aba c
abc = (ab)c
ab /ac = a(b-c)
b = a logab
bc = a c*logab
Sommations (Sec. 1.3.1)Logarithmes et Exposants (Sec. 1.3.2)
Techniques de preuves (Sec. 1.3.3)Probabilité de base (Sec. 1.3.4)
Les Maths que vous devez réviser
![Page 26: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/26.jpg)
Famille du “Grand-Oh”
big-Omega f(n) est (g(n)) s’il existe une constante c > 0
et un entier constant n0 1 tel que
f(n) c•g(n) for n n0
big-Theta f(n) est (g(n)) s’ils existent des constantes c’ > 0 et c’’ > 0 et
un entier constant n0 1 tel que c’•g(n) f(n) c’’•g(n) for n n0
little-oh f(n) est o(g(n)) si, pour toute constante c > 0, il existe un entier
constant n0 0 tel que f(n) c•g(n) pour n n0
little-omega f(n) est (g(n)) si, pour toute constante c > 0, il existe un entier
constant n0 0 tel que f(n) c•g(n) pour n n0
![Page 27: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/27.jpg)
Intuition pour la notation asymptotique
Big-Oh f(n) est O(g(n)) si f(n) est asymptotiquement inférieure ou égale à g(n)
big-Omega f(n) est (g(n)) si f(n) est asymptotiquement supérieure ou égale à
g(n)big-Theta
f(n) est (g(n)) si f(n) est asymptotiquement égale à g(n)little-oh
f(n) est o(g(n)) si f(n) est asymptotiquement strictement inférieur que g(n)
little-omega f(n) est (g(n)) si f(n) est asymptotiquement strictement supérieure
que g(n)
![Page 28: Analyse dAlgorithmes Algorithme Input Output Un algorithme est une procédure étape par étape pour résoudre un problème dans un temps fini. Structures de](https://reader036.vdocuments.mx/reader036/viewer/2022081420/551d9da7497959293b8d8ecc/html5/thumbnails/28.jpg)
Exemple Utilisation de la famille du “Grand-Oh”
f(n) est (g(n)) si, pour toute constante c > 0, il existe un entier constant n0 0 tel que f(n) c•g(n) pour n n0
besoin 5n02 c•n0 pour un c donné, le n0 qui satisfait cela est
n0 c/5 0
5n2 est (n)
f(n) est (g(n)) s’il existe une constante c > 0 et un entier constant
n0 1 tel que f(n) c•g(n) pour n n0
prendre c = 1 and n0 = 1
5n2 est (n)
f(n) est (g(n)) s’il existe une constante c > 0 et un entier constant
n0 1 tel que f(n) c•g(n) pour n n0
prendre c = 5 and n0 = 1
5n2 est (n2)