Algorithmique avancée et complexité

Cours 03
 Master Théorème
 Multiplication de matrices
 Algorithme de Strassen
 Limite inferieure de la complexité des algorithmes de tri qui utilisent la
comparaison comme opération fondamentale
Prof. Allaoua Refoufi
Université de Setif
Dpt Informatique
Email :allaoua.refoufi@univ-setif.dz
Lien du cours 03 sur Youtube :https://youtu.be/6csxAolWliM
 Master théorème

Résolution de la relation de récurrence

T(n)=aT(n/b)+nc

Rappel : Cette relation calcule la complexité d’un problème de taille n quand

on lui applique le paradigme « diviser pour régner »
 Rappel

La relation T(n)=aT(n/b)+nc nous aide à calculer la complexité

d’un problème de taille n quand on lui applique le paradigme
« diviser pour régner » où
 « a » est le nombre de sous problèmes
 n/b est la taille de chacun des sous problèmes
 T(n/b) est la complexité d’un des sous problèmes
 nc est l’effort fourni pour reconstituer la solution du problème
principal P.
 Master théorème

La solution de la relation T(n)=aT(n/b)+nc est :

T(n) = (nlogba) si a > bc
T(n) = (nclogbn) si a = bc
T(n) = (nc) si a < bc
a, b et c sont des constantes ≥ 0
 Résolution de T(n)= aT(n/b) + nc

La solution des relations de récurrence s’opère généralement par

développements successifs. On développe la relation à plusieurs
niveaux jusqu’à ce qu’on puisse « deviner » une forme générale qu’il
va falloir résoudre.
À partir de T(n)=aT(n/b) + nc on tire T(n/b)=aT(n/b2)+(n/b)c
Donc T(n)= a2T(n/b2) + a(n/b)c +nc = nc + nc(a/bc) + a2T(n/b2)
si on pousse plus loin on aura
T(n) = nc + (a/bc)nc + (a/bc)2nc +a3T(n/b3)
 Résolution de T(n)= aT(n/b) + nc

Si on généralise on peut écrire :

𝑘−1
T(n)= 𝑛𝑐 𝑖=0 (𝑎/𝑏𝑐) 𝑖
+𝑎𝑘 𝑇(𝑛 𝑏𝑘
)
On s’arrête quand 𝑛 =1 donc k = logbn
𝑏𝑘
On a aussi 𝑎𝑘 = 𝑎 𝑙𝑜𝑔𝑛
= 𝑛𝑙𝑜𝑔𝑎
Sachant que 𝑛 𝑖
0 𝑥 = (𝑥 𝑛+1
− 1)/(𝑥 − 1) = (𝑥 𝑛 )
**Remarque tous les log sont en base b
On distingue 3 cas :
1) Si a < bc il vient : S =
𝑎 𝑎 𝑖 = 1
𝑘−1
0
𝑖 ≤ ∞
0 𝑎 =  (1)
bc bc 1− c
b
Donc T(n)=nc(1) + nloga = (nc)
car si a < bc donc logba < c
2) Si a = bc dans ce cas : S = 𝑘−1
0 1 = 𝑘 − 1 = (logbn)
Par consèquent T(n) = nc(logbn) + nloga = (nclogbn)
car si a = bc donc logba = c
3) Si a > bc alors
𝑘−1 𝑎 𝑖 𝑎 k 𝑎𝑙𝑜𝑔𝑛
S= 0 (𝑏 𝑐 ) = (( 𝑐) ) = ( )
𝑏 𝑛𝑐
𝑐𝑘 𝑐 𝑙𝑜𝑔𝑛
En effet si on pose x = 𝑏 =𝑏
𝑎𝑙𝑜𝑟𝑠 𝑙𝑜𝑔𝑥 = 𝑙𝑜𝑔𝑛𝑙𝑜𝑔𝑏 𝑐 = clogn= log𝑛𝑐 donc x =𝑛𝑐
𝑎𝑙𝑜𝑔𝑛
Donc T(n) = nc( ) + 𝑛𝑙𝑜𝑔𝑎
𝑛𝑐
= (𝑛𝑙𝑜𝑔𝑎 ) + 𝑛 𝑙𝑜𝑔𝑎
= (𝑛𝑙𝑜𝑔𝑎 )
Puisque 𝑎𝑙𝑜𝑔𝑛 = 𝑛𝑙𝑜𝑔𝑎
 Applications du master théorème
Dans le cas de la recherche binaire on a T(n) =T(n/2)+1 donc a=1,
b=2 et c=0
Donc a = bc d’après le théorème on tire T(n)=(logn)
Dans le cas des algorithmes de tri on a T(n) =2T(n/2) +n
Donc a=b=2 et c=1
On a a=bc, d’après le théorème on tire que T(n)=(nlogn)
 Multiplication de matrices
Le produit de deux matrices X et Y de dimension nxn est une
matrice Z de même dimension telle que :
𝑛
Z[i,j]= 𝑘=1 𝑋[𝑖, 𝑘]𝑌[𝑘, 𝑗]
De complexité (n3)
Ce produit matriciel peut facilement être partitionné en
plusieurs sous problèmes pour lui appliquer le paradigme
« diviser pour régner »
Les matrices X,Y et Z seront partagés en sous matrices de
dimensions n/2 X n/2
 𝐴 𝐵 𝐸 𝐹
X= Y= On aura alors
𝐶 𝐷 𝐺 𝐻

𝐴𝐸 + 𝐵𝐺 𝐴𝐹 + 𝐵𝐻
XY= Il ne nous reste plus qu’à appliquer
𝐶𝐸 + 𝐷𝐺 𝐶𝐹 + 𝐷𝐻
la stratégie « diviser pour régner » en calculant récursivement les
produits matriciels AE, BG et ainsi de suite, qui sont des matrices de
dimension n/2 par n/2
On a alors 8 sous problèmes de dimension n/2. Pour recomposer la
solution initiale on doit faire 4(n/2)2 additions, en effet le produit AE
par exemple contient (n/2)2 éléments.
Il vient alors que T(n) = 8T(n/2) + n2 ce qui donne d’apres le Master
Théorème (a=8,b=c=2) T(n) =(n3) ce qui n’est guère une amélioration
par rapport à la méthode classique.
En 1969, le mathématicien allemand Volker Strassen annonça une
amélioration significative de la complexité du produit matriciel basée
sur le paradigme “diviser pour régner”
L’idée de Strassen est d’utiliser seulement 7 multiplications au lieu de
8 par une décomposition un peu étrange :
 𝑃5 + 𝑃4 − 𝑃2 + 𝑃6 𝑃1 + 𝑃2
XY =
𝑃3 + 𝑃4 𝑃1 + 𝑃5 − 𝑃3 − 𝑃7
où
P1 = A(F −H) P5 = (A+D)(E+H)
P2 = (A + B)H P6 = (B-D)(G+H)
P3 = (C + D)E P7 = (A-C)(E+F)
P4 = D(G−E)
On vérifie par exemple que P3+P4 =(C+D)E+D(G-E) =CE +DG
La relation de récurrence devient T(n) = 7T(n/2) + O(n2), qui a pour
solution O(nlog7) ≈ O(n2.81).
Une limite inferieure (nlogn) pour les algorithmes
de tri

Pour étayer cette proposition on va illustrer nos propos en tracant un

arbre de décision qui reflète un algorithme de tri.
Nous prenons comme exemple 3 nombres distincts a, b et c et
donnons en sortie leur ordre, comme le montre la figure suivante : on
commence par comparer a et b, puis b et c et ainsi de suite …
 a<b

a<c b<c

b<c (b, a, c) a<c (a, b, c)

(c, b, a) (b, c, a) (c, a, b) (a, c, b)

Une flèche vers la gauche indique que la condition est FAUSSE, à droite la
condition est VRAIE
Par exemple si a < b et b < c alors on aura comme sortie la liste (a,b,c)
La hauteur de cet arbre –le nombre de comparaisons sur le plus long chemin
de la racine à une feuille de l’arbre , dans cet exemple 3 – est precisément la
complexité dans le pire des cas de cet algorithme.
Si on généralise on peut affirmer que tout arbre qui tri n éléments doit avoir n!
feuilles, c’est-à-dire toutes les permutations des n nombres en entrée. Sinon
l’algorithme serait faux.
Sachant qu’un arbre binaire de hauteur h possède 2 h feuilles (preuve par
induction), il en ressort que notre algorithme va avoir comme complexité
log(n!) .
Il suffit donc d’evaluer log(n!) en utilisant la formule de Stirling.
On a alors n! 𝑛𝑛 𝑒 _𝑛 2𝑛
2

Donc log(n!) nlogn –nloge +log(2n)/2

Ce qui montre que log(n!) =(nlogn), on a donc établit que nlogn est
une limite inferieure de la complexité des algorithmes de tri qui
utilisent la comparaison comme opération fondamentale.
Conclusion
Théorème : le tri par fusion ainsi que le tri rapide dans le cas moyen
sont des algorithmes optimaux.