Cours - Coût et complexité.nb

Coût et complexité
Un algorithme doit déjà être correct, c’est-à-dire faire qu’il est supposé faire ! Mais il doit aussi être efficace, c’est-à-dire
donner “rapidement” la réponse: c’est l’objet de ce chapitre.
I) Coût et complexité d’un algorithme
1) Comment évaluer l’efficacité d’un algorithme ?
L’exécution d’un algorithme consomme de la mémoire (la RAM) et du calcul processeur. Tant que la RAM utilisée ne dépasse
pas la quantité maximale disponible, la consommation de mémoire ne ralentit pas l’exécution, et le temps de réponse est à peu près
proportionnel au nombre de calculs effectués par le processeur.
En réalité, certaines opérations élémentaires prennent plus de temps que d’autres. De plus, pour une même opération, le temps de
calcul est proportionnel à la taille des données (pour la multiplication des entiers, par exemple). On n’en tient pas compte ici et on
cherche seulement à évaluer le nombre de calculs “élémentaires” effectués lors de l’exécution de l’algorithme.
2) Coût d’un algorithme, opérations élémentaires
D Le coût d’un algorithme est le nombre d’opérations élémentaires effectuées par l’algorithme. Ces opérations élémentaires sont:
• faire une opération mathématique de base
I
+,*,ä,
ë
, )
• lire une valeur contenue dans une variable, affecter une valeur à une variable
• effectuer un test (comparaison, égalité), faire une opération booléenne (and, or, not)
Par exemple:
1. def somme_entiers(n):
2. total = 0
3. while n > 0:
4. total = total + n
5. n = n - 1
6. return total
Cette fonction (qui calcule la somme des entiers de 1 à n) fait:
• 2n opérations mathématiques (näL4 + näL5) • 4n + 1 lectures ( näL3 + 2näL4 + näL5 + L6)
• 2n + 1 affectations ( L2 + näL4 + näL5) • n comparaisons (näL3)
Le coût est de 9n + 2 opérations élémentaires
En pratique, on ne compte pas toutes les opérations élémentaires, mais seulement les plus significatives de l’algorithme. Ici,
par exemple, on ne comptera que le nombre d’additions de L4 (il y en a n), qui sont le cœur de cet algorithme.
3) La taille des données
D La taille des données d’un algorithme est (en général) un entier n qui “mesure” les données à traiter.
Par exemple:
• donnée = entier n ö taille = n • donnée = liste ö taille = longueur de la liste
Cours - Coût et complexité.nb 1/4

4) Estimation du coût d’un algorithme: la complexité
Calculer le coût exact d’un algorithme devient vite fastidieux et est souvent impossible. De plus, qu’il y ait n
2
ou n
2
+2n+3
opérations élémentaires, c’est pareil lorsque n est grand. D’où la notion de “complexité”.
Le rôle de la complexité est d’estimer, dans le cas le plus défavorable, un ordre de grandeur du coût d’un algorithme en fonction
de la taille n des données lorsque cette taille augmente et tend vers l’infini.
D La complexité d’un algorithme est en
f
H
n
L
lorsque le coût C
H
n
L
de l’algorithme, au pire, c’est à dire dans le cas le plus
défavorable, vérifie C
H
n
L
=O
H
f
H
n
L
L
. Il faut essayer de trouver la meilleure (la plus petite) fonction
f
possible.
On rappelle que:
•
f
H
n
L
=O
H
g
H
n
L
L
lorsque
f
g
est bornée en +¶ ñ $Mœ
+
,$n
0
œ
ë
"nrn
0
,f
H
n
L
bM g
H
n
L
• Si
f
H
n
L
~k g
H
n
L
avec kœ
*
+
alors
f
H
n
L
=O
H
g
H
n
L
L
.
L’algorithme donné en exemple dans le 2) est de complexité O
H
n
L
.
5) Complexités usuelles
Plus la complexité C
H
n
L
est "élevée", moins l'algorithme est efficace. Le plus souvent, on sera dans l’un des cas suivants:
D • C
H
n
L
=O
H
1
L
: l’algorithme a une complexité constante (parfait)
•
C
H
n
L
=
O
H
ln
H
n
L
L
: l’algorithme a une complexité logarithmique (excellent)
• C
H
n
L
=O
H
n
L
: l’algorithme a une complexité linéaire (très bon)
• C
H
n
L
=O
H
näln
H
n
L
L
: l’algorithme a une complexité quasi linéaire (très bon)
• C
H
n
L
=O
I
n
2
M
: l’algorithme a une complexité quadratique (moyen)
• C
H
n
L
=O
I
n
3
M
: l’algorithme a une complexité cubique (mauvais)
• C
H
n
L
=O
H
n
p
L
: l’algorithme a une complexité polynomiale (p > 3) (très mauvais)
• C
H
n
L
=C
H
a
n
L
: l’algorithme a une complexité exponentielle (a > 1) (catastrophique)
• C
H
n
L
=O
H
n!
L
: l’algorithme a une complexité factorielle (exécrable)
6) Ordre de grandeur des temps d’exécution suivant la complexité
On suppose que l’ordinateur effectue 10
7
opérations élémentaires par seconde. ( C’est à peu près le cas avec Python, mais C++
serait cent fois plus véloce). On donne le temps d’exécution T(n) en fonction de n selon la complexité C(n) de l’algorithme.
n \ C
H
n
L
ln
H
n
L
n
n
ln
H
n
L
n
2
n
3
n=10
2
500 ns 10 ms 46 ms 1 ms 100 ms
n=10
4
900 ns 1 ms 9 ms 10 s 28 h
n=10
6
1ms 100 ms 1 s 28 h X
n=10
8
2ms 10 s 200 s 31 a X
n \ C
H
n
L
2
n
n!
n=10 100 ms 300 ms
n=20 100 ms 7700 a
n=100 4 *10
15
a X
Un algorithme qui résout théoriquement un problème mais qui ne donne jamais la réponse est une curiosité guère utile...
II) Exemples
Indiquez le paramètre mesurant la taille des données, les opérations élémentaires caractéristiques effectivement comptées et la
complexité. Expliquez ce que calculent les algorithmes, donnez des exemples. Donnez aussi s’il y a lieu des exemples ou l’algo-
rithme s’exécute le plus vite (meilleur des cas) ou le moins vite (pire des cas) possible.
Cours - Coût et complexité.nb 2/4

1) Algorithmes sans boucles “for” ou “while” : complexité O
H
1
L
def f1(n): # n est un entier
return ((n % 400) == 0) or (((n % 4) == 0) and ((n % 100) != 0))
2) Algorithmes avec uniquement des boucles “for” : complexité O
H
longueur de la boucle
L
def f2(n): # n est un entier
s = 0
for k in range(1, n + 1):
s = s + k**3
return s
def f3(n): # n est un entier
a, b = 1, 1
for i in range(n - 1):
a, b = b, a + b
return b
from math import *
def f4(n): # n est un entier
for d in range(2, floor(sqrt(n)) + 1):
if (n % d) == 0:
return False
return True
def f5(n): # n est un entier
s = 0
for i in range(1, n + 1):
for j in range(1, i + 1):
s = s + i / j
return s
3) Algorithmes avec une boucle “while” : complexité plus difficile à calculer
def f6(n): # n est un entier
p, q = 0, n
while q % 2 == 0:
p, q = p + 1, q // 2
return (p, q)
On démontrerait (pas si facile) que l’algorithme qui suit (Euclide) a une complexité en O
H
ln
H
b
L
L
def pgcd(a, b): # a et b sont des entiers avec a r b
"""pgcd des entiers a et b"""
while b > 0:
a, b = b, a % b
return a
III) Exercices
1) Etude d’une suite (c’est celle du DM 3)
On pose x
0
=1 et "nœ,x
n+1
=x
n
+
1
x
n
. On démontre (maths) que x
n
-2nö0. On donne les trois fonctions:
def x(n):
s = 1
for i in range(n):
s = s + 1/s
return s
def recherche_1(eps):
""" Plus petit entier n tel que x(n) - sqrt(2*n) <= eps"""
n = 0
while x(n) - sqrt(2*n) > eps:
n = n + 1
return n
def recherche_2(eps):
Cours - Coût et complexité.nb 3/4

""" Plus petit entier n tel que x(n) - sqrt(2*n) <= eps"""
x, n = 1, 0
while x - sqrt(2*n) > eps:
x = x + 1/x
n = n + 1
return n
On note C
1
H
¶
L
et C
2
H
¶
L
le coût des fonctions recherche_1(eps) et recherche_2(eps). On note n le retour de ces fonctions.
a) Justifier (théoriquement) l’existence de constantes k
1
et k
2
telles que C
1
H
¶
L
ºk
1
n
2
et C
2
H
¶
L
ºk
2
n
b) Expliquez pourquoi les tests de calculs de durées suivants sont cohérents avec le calcul théorique du a)
recherche_1(0.05): n = 1435 ; Durée = 0.1715 s
recherche_1(0.03): n = 4963 ; Durée = 2.045 s
recherche_2(0.05): n = 1435 ; Durée = 0.000775 s
recherche_2(0.03): n = 4963 ; Durée = 0.002642 s
recherche_2(0.001): n = 12206465 ; Durée = 6.49 s
c) Combien de jours prendrait environ l’exécution de recherche_1(0.001) ?
2) Calcul de la somme maximum de termes consécutifs d’une liste de nombres
Etant donnée une liste s de nombres, les 3 fonctions suivantes calculent M
H
s
L
=max S
k=i
j
s
@
k
D
ê
0bibj<n=len
H
s
L
.
Expliquer leur fonctionnement et calculer leur complexité.
def somme_max_1(s):
n, maxi = len(s), s[0]
for i in range(n):
for j in range(i, n):
somme = 0
for k in range(i, j + 1):
somme = somme + s[k]
if somme > maxi:
maxi = somme
return maxi
def somme_max_2(s):
n, maxi = len(s), s[0]
for i in range(n):
somme = 0
for j in range(i, n):
somme = somme + s[j]
if somme > maxi:
maxi = somme
return maxi
def somme_max_3(s):
n, maxi, somme = len(s), 0, 0
for i in range(n):
if somme > 0:
somme = somme + s[i]
else:
somme = s[i]
if somme > maxi:
maxi = somme
return maxi
Cours - Coût et complexité.nb 4/4