Calcul de complexité

TSOPZE N.
 Préliminaires
 algorithme : ensemble d'opérations de calcul élémentaires,
organisé selon
 des règles précises pour résoudre un problème précis.
 retourne une réponse après un nombre fini d'opérations.
 opérations élémentaires
 opérations arithmétiques,
 transferts de données,
 comparaisons entre données, etc.
 niveau d'abstraction : opérations arithmétiques et objets sur
lesquels elles portent peuvent être plus ou moins complexes:
 additionner des entiers naturels,
 multiplier des polynômes
 Préliminaires
 élémentaires : opérations ayant le temps de calcul constant
 Structure de contrôle : détermine l'ordre dans lequel il
convient:
 tester des conditions,
 répéter des opérations,
 recommencer tout ou partie des calculs sur un sous-ensemble de
données, etc.
 conventions sur la façon de mesurer le coût des opérations;
 Mesure de coût
 problème donne P,
 algorithme A pour le résoudre;
 Sur la donnée x de taille n, l'algorithme requiert, mesure en nombre
d'Operations élémentaires: c(x).
 Le coût en temps varie :
 taille de la donnée,
 les différentes données de même taille n
 Dépend:
 De la machine sur lequel s’exécute l’algorithme,
 de la traduction de l’algorithme en langage exécutable par la machine
Mais en général le coût est en fonction de la taille n des
données.
 Mesure de coût
 Cas défavorable ou pire des cas: définition le maximum des coûts
𝐶 𝑛 = max 𝐶(𝑥)
𝑥 =𝑛
 Cas moyen: connaisse une distribution de probabilités sur les
données de taille n.
 p(x) est la probabilité de la donnée x,
 le coût moyen

∁ 𝑛 = 𝑝 𝑥 𝑐(𝑥)
𝑥 =𝑛
 Meilleur des cas: 𝐶 𝑛 = min 𝐶(𝑥)
𝑥 =𝑛
 Complexité
 complexité des algorithmes est une évaluation du coût
d’exécution d’un algorithme en termes de temps
(complexité temporelle) ou d’espace mémoire (complexité
spatiale).
 Utilisée pour comparer deux algorithmes dans leur
comportement asymptotique
Notations de Landeau
 g : R R. Etant donné un point x0  R  ] -, + [
 O(g) : ensemble des fonctions f pour lesquelles il existe un
voisinage V de x0 et une constante k > 0 tels que
|f(x)| ≤ k|g(x)|
 voisinage d'un point x0 = partie de R contenant un intervalle
ouvert contenant le point x0
|𝑓 𝑥 |
 Cela revient à calcule à l’infini
|𝑔 𝑥 |
 Notations de Landeau
Opérations
 f+ O(g) = {f + h / h  O(g)}
 fO(g) = {fh / h  O(g)}
 h = f + O(g) si et seulement si h- f  O(g
Formules
 f = O(f)
 O(-f) = O(f)
 cO(f) = O(f)
 O(f) + O(f) = O(f)
 O(f)O(g) = O(fg)
 fO(g) = O(fg)
 Si f et g sont a valeurs positives, alors O(f) + O(g) = O(f + g)
Notations de Landeau
 (g) = ensemble des fonctions f pour lesquelles il existe
deux nombres k; a > 0 tels que:
|f(x)| ≥ k|g(x)| pour tout x > a
Donc f  (g)  g  O(f)
 (g) = ensemble des fonctions f pour lesquelles il existe des
nombres k1, k2, a > 0 tels que:
k1 |g(x)| ≤ |f(x)| ≤ k2 |g(x)| pour tout x > a
Donc  (g) = O(g)   (g)
Récurrences
 Une suite récurrente linéaire est une suite (Un) n≥0 de
nombres (réels) qui vérifie une relation du type suivant :
Un+h = ah-1Un+h-1 + … + a0Un; n = 0; 1; 2;… a0≠ 0
où h est un entier strictement positif et ah-1; … ; a0 sont des
nombres fixes.
Un est entièrement déterminée par ses h premières valeurs
u0;… ; uh-1 et est une suite d'ordre h.
 Le polynôme associé ou caractéristique est par définition
G(X) = Xh – ah-1Xh-1 -…- a1X - a0
Récurrences (équations)
 équation reliant le neme terme à ses prédécesseurs
 Autre appellation : équation aux différences.
 résolution : trouver une expression du neme terme
en fonction du paramètre n.
 deux catégories:
 Linéaires
 Non linéaires
Récurrences (équations à coef. const)
 Une suite de nombres (t(1), . . . , t(n), . . .) satisfait une
relation de récurrence linéaire d’ordre k si, et seulement
si, il existe des constantes c0, . . . , ck telles que
1. ckt(n + k) + ck−1t(n + k − 1) + . . . + c0t(n) = g(n)
2. t(n0) = d0, . . . , t(n0 + k − 1) = dk−1
 g(n) : fonction quelconque en n.
 di : constantes définissant les conditions initiales
nécessaires pour démarrer une récurrence à partir de n0.
 t(n + k) : terme qui détermine l’ordre de l’équation

Si g(n) = 0 alors on dit que la relation (1) est homogène. Sinon, elle est dite
non-homogène.
Récurrences (équations homogènes)
ckt(n + k) + ck−1t(n + k − 1) + . . . + c0t(n) = 0
t(n0) = d0, . . . , t(n0 + k − 1) = dk−1
 L’équation caractéristique de la relation correspond à
l’équation polynomiale:
ckrk + ck−1rk−1 + . . . + c1r + c0 = 0.

 Exemple:
4t(n + 3) + 7t(n + 1) − t(n) = 0 a pour équation
caractéristique 4r3 + 7r − 1 = 0
Récurrences (équations homogènes)
Théorème : La solution générale de l’équation est de la
forme suivante:
𝑙 𝑚𝑖 −1

𝑡 𝑛 = 𝑟𝑖 𝑛 𝑎𝑖𝑗 𝑛𝑗
𝑖=1 𝑗=1
 l : nombre de racines distinctes de l’équation;
 ri : racine de l’équation.
 mi : multiplicité de la racine ri.
 aij : constantes qui sont déterminées à partir des
conditions initiales
Récurrences (équations homogènes)
 3 racines distinctes :
 r1 (racine triple),
 r2 (racine double)
 r3 (racine simple), alors
 la solution générale est :
t(n) = rn1 (a1 + a2n + a3n2) + rn2 (a4 + a5n) + a6r n

Il faut remplacer les valeurs de ri dans t(n), résoudre encore les équations
pour trouver les valeurs des ai.
Exemple: suite de Fibonacci (t0=0, t1=1, t(n)=t(n-1)+t(n-2))
Récurrences (équations non homogènes)
1. ckt(n + k) + ck−1t(n + k − 1) + . . . + c0t(n) = g(n)
2. t(n0) = d0, . . . , t(n0 + k − 1) = dk−1
 Résolution:
1. éliminer d’abord la fonction g(n),
2. résoudre l’équation homogène obtenue
 Approche
1. Supposer que la récurrence est aussi à n+1 et écrire
l’équation à n+1
2. Soustraire l’équation à n de l’équation à n+1
Récurrences (équations non homogènes)
Soit à résoudre l’équation
t(n + 2) − t(n + 1) − t(n) = 4. (*)
1. À n + 1, on a:
t(n + 3) − t(n + 2) − t(n + 1) = 4 (**)
2. (**)-(*) donne
t(n + 3) − 2t(n + 2) + t(n) = 0 qui peut être résolu
comme un cas homogène
Récurrences (équations non homogènes)
résoudre la partie homogène de l’équation
ckt(n + k) + ck−1t(n + k − 1) + . . . + c0t(n) = 0 dont
les racines sont ri
Suposons que 𝑔 𝑛 = 𝑖 𝑝𝑖 (𝑘)𝑐𝑖 𝑘
La solution est celle de l’équation :
(partie homogène)(x-ci)degre(pi(k)+1)=0
Exemple:fk-2fk-1=2k == (x-2)(x-2)=0
Fk=c12k+c2k2k
Récurrences (équations non linéaires)
 Très utile pour le calcul des complexités des
algorithmes DPR
 transformer l’équation en une autre équivalente facile à
résoudre
 Pour un algorithme DPR, sa forme générale est:
t(n) = at(n/b) + cnk
t(n0) = d.
k est une constante
n une puissance de k (n = km).
Récurrences (équations non linéaires)
 Théorème : Pour les fonction g(n) = (nd), la solution
de l’équation (t(n) = at(n/b) + cnk )est comme suit:
1. t(n) = (nk) si a<bk,
2. t(n) = (nk logbn) si a= bk
3. t(n) = (nlogba) si a> bk

valables pour les autres notations

Complexité en temps
 Permet de juger un algorithme indépendamment de son
implémentation
 La plus utilisée pour l’évaluation d’un algorithme
 Évaluer le temps (théoriquement) utilisé pour l’exécution en
fonction de la taille des données
 Le plus souvent dans l’ordre asymptotique
 Ne pas confondre avec le temps d’exécution
Complexité en espace
 Évaluer toutes les ressources matérielles utilisées
(théoriquement) pour la mise en place de l’exécution de
l’algorithme
 Tenir compte des structures de données
 Tableau
 Listes
 Piles
 Arbres
 Matrice
…
Règles de calcul
 Structures de contrôle
 séquence
 embranchement (ou sélection)
 boucle (ou itération)
 Structures de données
 constantes
 variables
 tableaux
 structures récursives (listes, arbres, graphes)
 Règles de calcul
Enchaînement
 Soient deux suites d’actions
Debut A1 et A2, et A1+A2, la suite
« A1 suivi de A2 » Alors:
Action A1
Action A2
TA1+A2(n) = TA1(n)+ TA2(n)
fin
 Règles de calcul
Algorithme Conditionnelle

Debut TA(n) = TC(n) + Max( TA1(n),TA2(n))

Si C alors
Action A1
sinon
Action A2
fin
 Règles de calcul
Algorithme
Debut
TantQue C Faire
A1
FinTantQue
fin

Itération (TantQue)
 En notant niter(n) le nombre d’itérations, on a:
𝑛𝑖𝑡𝑒𝑟(𝑛)

𝑇𝐴 𝑛 = (𝑇𝑐 𝑖, 𝑛 + 𝑇𝐴1 (𝑖, 𝑛)) + 𝑇𝐶 (𝑛𝑖𝑡𝑒𝑟 𝑛 + 1, 𝑛)

𝑖=1
 Règles de calcul (sous algo)
Tenir compte du temps d’exécution du sous algorithme dans le calcul
Enchainement:
TActions+sou-algo(n) = TActions(n)+ Tsous-algo(n)

Conditionnelle
boucle
𝑇𝐴 𝑛
𝑛𝑖𝑡𝑒𝑟(𝑛)

= (𝑇𝑐 𝑖, 𝑛 + 𝑇𝐴𝑐𝑡𝑖𝑜𝑛𝑠 𝑖, 𝑛 + 𝑇𝑠𝑜𝑢𝑠−𝑎𝑙𝑔𝑜 ) + 𝑇𝐶 (𝑛𝑖𝑡𝑒𝑟 𝑛 + 1, 𝑛)

𝑖=1