ALGO1 – Diviser pour r´egner Fran¸cois Schwarzentruber September 28, 2020

(1)

ALGO1 – Diviser pour r´egner

Fran¸cois Schwarzentruber September 28, 2020

1 Motivation

Complexité d’un algo na¨ıf Complexité d’un algo efficace obtenu via diviser pour régner Chercher un élément dans un

tableau trié ànéléments Tri par comparaison d’un tableau de taillen

Calcul du k-ième élément d’un tableau à néléments

Multiplication de nombres `a n bits chacun

Multiplication de matrices de taillen×n

Calcul de la transform´ee de Fourier d’un signal de n

´

echantillons

2 Principe

Probl`eme initial : trier [1 10 4 2 5 3 9 8]

Sous-probl`eme 1 : trier [1 10 4 2]

Sous-probl`eme 2 : trier [5 3 9 8]

[1 2 4 10]

[3 5 8 9]

[1 2 3 4 5 8 9 10]

R´egner

Diviser Combiner

3 Exemples

Dichotomie

...

Tri fusion

...

Tri rapide

...

4 Th´ eor` eme fondamental sur la complexit´ e

Théorème 1 Soita≥1, d≥2 etb≥0. Considérons une suite(τ(n))_n∈_N qui vérifie, pour toutn≥2,

(2)

τ(n) =aτ dn

de

+O(n^b).

Alors :

si a < d^b, τ(n) =O(n^b)

sia=d^b, τ(n) =O(n^b×hauteur)

=O(n^blog_dn)

sid^b < a, τ(n) =O(nb feuilles)

=O(a^log^dⁿ) =O(n^log^dâ) Démonstration. On travaille à constante près. Donc on s’intéresse en fait à la suite suivante :

τ(n) =aτ dn

de +n^b et τ(1) = 1.

Quandn=d^h Démontrons d’abord le résultat lorsque nest une puissance ded, autrement dit quen=d^h pour un certain h, qui est la hauteur de l’arbre des appels. A la profondeur `, le coût dans un nœud est _dⁿ`b^b et il y a a^` nœuds.

Le tableau suivant résume les complexités à chaque niveau d’appels :

Niveau` Complexit´e dans un nœud Complexit´e totale sur le niveau

0 (racine) n^b 1×n^b

1 ⁿ_d_b^b a×ⁿ_d_b^b

... ... ...

` _dⁿ_`b^b a^`×_dⁿ_`b^b

... ... ...

h(feuilles) 1 a^h

Autrement dit,

τ(n) :=

h

X

`=0

a^`× n^b d^`b =n^b

h

X

`=0

a d^b

^` .

1. Sia < d^b, alors la raison de la s´erie est plus petite que 1 et donc la s´erie converge. Doncτ(n) =O(n^b).

2. Sia=d^b, alors la raison vaut 1 et la somme vaut h=O(logn). Donc τ(n) =O(n^blogn).

3. Sib^d< a, alors la raison est plus grande que 1 et la s´erie diverge. Doncτ(n) =O(n^b _d^ab

log_dn

) =O(n^log^d^a).

Cela termine la preuve pour le comportement asymptotique quandntend vers l’infini en prenant pour valeur des puissances ded.

Remarque 2 Il faut bien ˆetre `a l’aise avec les logarithmes. Voici les points clefs :

• x=d^log^d^x pour toute based >1 et pour tout nombrex >0;

• tout se passe bien avec un exposant : x^t= d^log^d^xt

=d^tlog^d^x.

nquelconque Maintenant si nest quelconque, on a l’encadrementd^log^dⁿ≤n < d×d^log^dⁿ. Lemme 3 La fonctionτ :N→Rest croissante.

D´emonstration. Pour le montrer, on montre par r´ecurrence surnqueτ est croissante sur {1, . . . , n}.

• Pour n= 1, la propri´et´e est triviale.

(3)

• Supposons pour unndonn´e queτest croissante sur{1, . . . , n}et montrons queτest croissante sur{1, . . . , n+ 1}.

On a :

τ(n+ 1) =aτ dⁿ⁺¹_d e

+ (n+ 1)^b ≥aτ dⁿ_de

+n^b =τ(n) par hypothèse de récurrence (là on utilise qued≥2 pour être sûr quedⁿ⁺¹_d e ≤n).

• Par r´ecurrence, on a montr´e que τ est croissante surN.

On conclut de la mani`ere suivante. Par exemple, sib > logda, on aτ(n)≤τ(d^dlog^d^ne) car τ est croissante. Mais on aτ(d^dlog^d^ne) =O(d^dlog^d^neb) =O((dd^blog^d^nc)^b)≤O(dn^b) =O(n^b).

5 Algorithme de Karatsuba

D´efinition 4 (probl`eme de la multiplication de nombres)

• Entr´ee : deux entiers x,y donn´es en base 2 avecn chiffres ;

• Sortie : le produit dexety,x×y, donn´ee en base 2 avec2nchiffres.

Théorème 5 L’algorithme de multiplication appris à l’école primaire est en Θ(n²).

1 2 3 4

× 5 6 7 8 6 3 8 7 4 0 4 6 1 7 0 6 9 9 6 7 8

Th´eor`eme 6 L’algorithme de Karatsuba est enO(n^log²³) . pre : deux entiersx,y den-bits

post : le produitxy fonction karatsuba(x, y)

sin= 1alors retourner xy sinon

x_G, x_D := lesdⁿ₂ebits les plus `a gauche, lesbⁿ₂cbits les plus `a droite dex;

yG, yD := lesdⁿ₂ebits les plus `a gauche, lesbⁿ₂cbits les plus `a droite dey;

P1=produit(xG, yG) P2=produit(xD, yD)

P3=produit(xG+xD, yG+yD)

retourner 2ⁿP1+ 2ⁿ²(P3−P1−P2) +P2

5.0.1 Premier tentative de diviser pour r´egner

Appliquons ‘diviser pour régner’ pour créer un algorithme plus performant. Découpons les deux nombresxetycomme suit :

x= 2^bⁿ²^cx_G+x_D ety= 2^bⁿ²^cy_G+y_D oùx_G, y_G, x_D, y_Dsont des nombres entre 0 et 2^dⁿ²ê−1. On écrit :

xy= 2^2bⁿ²^cxGyG+ 2^bⁿ²^c(xGyD+yGxD) +xDyD.

La multiplicationxyse ramène à 4 multiplications avec des nombres avec 2 fois moins de bits, puis des additions, et multiplication par des puissances de deux soit duO(n). Le cas de base correspond à une multiplication avec des nombres avec 1 bit chacun. Cela donne

τ(n) = 4τ dⁿ₂e

+O(n)., donc du O(n²), pas mieux qu’`a l’´ecole primaire.

(4)

5.0.2 Deuxi`eme tentative

Voici l’astuce de Gauss (ou Karatsuba) :

xGyD+yGxD= (xG+xD)(yG+yD)−xGyG−xDyD.

Ainsi on se ramène à uniquement 3 multiplications, certes avec des additions supplémentaires mais qui ne coûtent pas si chères. On a :

xy= 2ⁿP1+ 2ⁿ²(P₂−P₁−P₃) +P₃ avecP₁=x_Gy_G et P₂= (x_G+x_D)(y_G+y_D) et P₃=x_Dy_D.

Chaque addition coûteO(n). Chaque multiplication par une puissance de 2 coûteO(n) (il faut juste décaler les bits). La relation de récurrence donne :

τ(n) = 3τ dⁿ₂e

+O(n), doncO(n^log²³), soit environO(n^1.59).

Remarque 7 Remarque technique concernant le produit P2. Les repr´esentations binaires des nombres xG+xD et yG+yD peuvent avoir 1 +dⁿ₂ebits, i.e. d´epasserdⁿ₂e. Mais ce n’est pas grave. En effet, en toute rigueur on devrait

´ecrire ce produit sous la forme

(a2^dⁿ²ê+1+A)×(b2^dⁿ²ê+1+B) =ab^2dⁿ²ê+2+ 2^dⁿ²ê+1(aB+bA) +AB

où a etb sont des bits. Il y a un traitement en O(n) plus l’appel récursif correspondant au produit AB. On a caché ce détail dans le pseudo-code ci-dessous.

pre : deux entiersx,y den-bits post : le produitxy

fonction produit(x, y) sin= 1alors

retourner xy sinon

x_G, x_D := lesdⁿ₂ebits les plus `a gauche, lesbⁿ₂cbits les plus `a droite dex;

y_G, y_D := les dⁿ₂ebits les plus `a gauche, lesbⁿ₂cbits les plus `a droite dey;

P₁=produit(x_G, y_G);

P2=produit(xD, yD);

retourner 2ⁿP1+ 2ⁿ²(produit(xG+xD, yG+yD)−P1−P2) +P2

6 Algorithme de Strassen

D´efinition 8 (probl`eme de la multiplication de matrices)

• Entr´ee : deux matricesX et Y de taille n;

• Sortie : le produitXY.

Th´eor`eme 9 L’algorithme na¨ıf est enΘ(n³).

Th´eor`eme 10 L’algorithme de Strassen est enΘ(n^2.81).

L’objectif est de cr´eer un algorithme efficace pour calculer le produitXY de deux matricesX etY de taillen×n.

L’algorithme na¨ıf calcule chaque terme deXY enO(n) et il y an² termes, d’o`u une complexit´e totale deO(n³).

6.0.1 Premier essai diviser pour r´egner

L’idée consiste à découper les matrices en sous-blocs de la fa¸con suivante : content...

X =

A B

C D

et Y =

E F

G H

. On a alors : XY =

AE+BG AF+BH CE+DG CF +DH

. D’o`u T(n) = 8T(ⁿ₂) +O(n²), i.e. T(n) =O(n^log²⁸) =O(n³).

(5)

6.0.2 Algorithme de Strassen

L’algorithme de Strassen calculeXY `a partir de seulement 7 produits de matrices plus petites et non pas 8 ! En fait on a

Algorithme de Strassen En ´ecrivantX =

A B

C D

etY =

E F

G H

, calculer XY =

P5+P4−P2+P6 P1+P2

P3+P4 P1+P5−P3−P7

où ces produits sont calculés récursivement :

• P1=A(F−H)

• P2= (A+B)H

• P3= (C+D)E

• P4=D(G−E)

• P5= (A+D)(E+H)

• P₆= (B−D)(G+H)

• P7= (A−C)(E+F) On a donc un algorithme de type diviser pour régner vérifiant la relation de récurrence :

T(n) = 7T(ⁿ₂) +O(n²) d’où d’après le théorème fondamental,T(n) =O(n^log²⁷) =O(n^2.81).

Le meilleur algorithme connu à ce jour, dû à Coppersmith-Winograd [?], est enO(n^2.376).

7 Transformation de Fourier Discr` ete Rapide (FFT)

Définition 11 La transformée de Fourier Discrète est le problème algorithmique :

• entr´ee :

– un polynˆomeA=Pn−1

i=0 aiXⁱ, d´ecrit avec un vecteur~a= (a0, a1, . . . , a_n−1);

– une racinen^`^eme de l’unit´eω ; par exemple ω=e^2πiⁿ

• sortie : A(ω⁰), A(ω), . . . , A(ωⁿ⁻¹).

Th´eor`eme 12 L’algorithme na¨ıf est en Θ(n²).

7.1 Principe

On d´ecompose le polynˆomeAen sa partie paireP, et impaireI : A=P(X²) +X×I(X²).

Exemple 13

A = 1 +6X −3X² +2X³ +X⁴ −7X⁵

P = 1 −3X +X²

I = 6 +2X −7X²

entrée : un polynômeA, une racine de n-ème de l’unitéω sortie : A(ω⁰), A(ω), . . . , A(ωⁿ⁻¹)

fonction FFT(A, ω) siAest constant

retourner A(1) sinon

soitP la partie paire etIla partie impaire deA calculerP(1), P(ω²). . . , P(ωⁿ⁻²) viaF F T(P, ω²) calculerI(1), I(ω²). . . , I(ωⁿ⁻²) viaF F T(I, ω²) pour k= 0 `an−1

A(ω^k) := P(ω^2k) +ω^kI(ω^2k) retourner A(ω⁰), A(ω), . . . , A(ωⁿ⁻¹) Théorème 14 La complexité est enO(nlogn).

D´emonstration.

τ(n) = 2τ dn

2e

+O(n).

(6)

7.2 Pseudo-code d´ etaill´ e

On considère ici une racine n-ème de l’unitéω . Ainsiω^n/2=−1.

Posons (s0, . . . , s_n/2−1) = (P(1), P(ω²). . . , P(ωⁿ⁻²) et (s⁰₀, . . . , s⁰_n/2−1) = (I(1), I(ω²). . . , I(ωⁿ⁻²). On a pour toutk,

A(ω^k) =P(ω^2k) +ω^kI(ω^2k).

• pour toutk≤ ⁿ₂−1, on aA(ω^k) =P(ω^2k) +ω^kI(ω^2k) =sk+ω^ks⁰_k;

• pour toutk≤ ⁿ₂−1, on aA(ω^k+n/2) =P(ω^2(k+n/2)) +ω^k+n/2I(ω^2(k+n/2)) =P(ω^2k)−ω^kI(ω^2k) =s_k−ω^ks⁰_k. entrée : des nombres a0, . . . , a_n−1, et une racinen-ème de l’unité primitiveω

sortie : A(ω⁰), A(ω), . . . , A(ωⁿ⁻¹) o`u A=Pn−1 i=0 aiXⁱ fonction FFT(a0, . . . , an−1, ω)

sin= 1

retourner a0

sinon

(s0, . . . , s_n/2−1) :=F F T(a0, a2, . . . , a_n−2, ω²) (s⁰₀, . . . , s⁰_n/2−1) :=F F T(a1, a3, . . . , an−1, ω²) α:= 1

pour k= 0 `an/2−1 y_k =s_k+αs⁰_k

y_k+n/2=s_k−αs⁰_k op´eration papillon α:=α×ω

retourner y0, . . . , yn−1

7.3 Circuit pour la FFT

Voici l’arbre des appels r´ecursifs de la FFT :

L’ordre 0, 4, 2, 6, 1, 5, 3, 7 s’obtient en prenant les miroirs des ´ecritures binaires de 0, 1, 2, 3, 4, 5, 6, 7.

Le circuit suivant repr´esente le calcul de la FFT, en lisant l’arbre ci-dessous. Les feuilles sont les entr´ees.

Le calcul en bleu dans l’algorithme s’appelle une opération papillon : on la représente par une croix bleue, agrémentée par la valeur deα.

y0

y₁ y2

y3

y₄ y₅ y6

y7

a₀ a4

a2

a₆ a₁ a5

a3

a₇

000|000 001|100 010|010 011|011 100|001 101|101 110|011 111|111

ω0

ω0 ω2

ω0 ω1

ω2 ω3

Théorème 15 Il y a Θ(nlogn) opération papillons.

Théorème 16 Le circuit est de profondeur Θ(logn) . L’algorithme s’exécute en Θ(logn) sur une architecture parallèle.

(7)

7.4 Algorithme it´ eratif

entrée : des nombresa₀, . . . , a_n−1, et une racinen-ème de l’unité primitiveω sortie : A(ω⁰), A(ω), . . . , A(ωⁿ⁻¹) oùA=Pn−1

i=0 a_iXⁱ fonctionFFT(a₀, . . . , a_n−1, ω)

pour k= 0 `an−1faire sk:=amiroir(k)

pour m:= 2,4,8, . . . , nfaire ω:=e^2iπ/m

pour k= 0, m,2m, . . . , n−mfaire α:= 1

pour j= 0 `a m/2−1 faire

sk+j, s_k+j+m/2=sk+j+αs_k+j+m/2, sk+j−αs_k+j+m/2 α:=α×ω

retourner s₀, . . . , s_n−1

7.5 Transformation de Fourier inverse

D´efinition 17 (matrice de Vandermonde) V(ω) =







1 1 1 . . . 1

1 ω ω² . . . ωⁿ⁻¹ 1 ω² ω^2×2 . . . ω^2×(n−1) ... . . ...

1 ωⁿ⁻¹ ω^(n−1)×2 . . . ω^{(n−1)(n−1)}





 .

Proposition 18 La transformée de Fourier Discrète revient à calculerV(ω)~aoùωracinen-ème primitive de l’unité.

Théorème 19 Si ω est une racinen-ème primitive de l’unité, V(ω)⁻¹= _n¹V(ω⁻¹).

La transform´ee de Fourier est le vecteur~y=V(ω)~a. La transform´ee inverse est :~a:=V(ω)⁻¹~y..

Corollaire 20 On peut calculer la FFT inverse en appelant le mˆeme algo : _n¹F F T(~y, ωn−1).

7.6 Multiplication de polynˆ omes

Algorithme pour multiplier deux polynômes représentées par coefficients

1. On évalue les polynômesA,B de degrén/2 en les points 1, ω, . . . , ωⁿ⁻¹ oùω=e^2πiⁿ ;(FFT) 2. On effectue la multiplication par valeur, on cal-

culeC(1) =A(1)B(1), C(ω) =A(ω)B(ω), etc.

3. On interpole C pour obtenir ses coefficients.

(FFT inverse)

Repr´esentation par coefficients Multiplication

Repr´esentation par valeurs auxnracines de l’unit´e Multiplication

Evaluation en´ Θ(n)racines de l’unit´e FFTO(nlogn)

Interpolation FFT inverseO(nlogn)

Corollaire 21 On peut multiplier deux polynˆomes de degr´eO(n)enO(nlogn).

8 Type abstrait ‘Polynˆ ome’

Voici le type abstrait d’un polynˆome :

• Evaluer le polynˆ´ ome en un point ;

• Addition de deux polynˆomes ;

• Multiplier deux polynômes ;←là, on se concentre sur cette opération

• Calculer une racine ;

• D´eriver, etc.

(8)

8.1 Impl´ ementations par coefficients

A=

n−1

X

i=0

aiXⁱ

On stocke les coefficientsa0, . . . , a_n−1dans un tableau.

Evaluation´ On utilise la r`egle de Horner en Θ(n) :

A(8) =a0+8×(a1+8×(a2+...+8×(a_n−2+8×a_n−1))...)) Addition En Θ(n) : on somme coefficients par coefficients.

Multiplication On cherche le produit de deux polynômesAet B de degrén−1 définis par : A=

n−1

X

i=0

aiXⁱ, B=

n−1

X

i=0

biXⁱ.

Le r´esultat est le polynˆomeC=P2n−2

k=0 ck de degr´e 2n−2, avec : ck=

k

X

i=0

aib_k−i.

Remarque 22 En théorie du signal, on peut avoir envie de construire un signal c à partir d’une superposition de signauxbdécallés, pondérés par des coefficientsa. C’est exactement le calcul ci-dessus !

L’implémentation directe du produit de 2 polynômes est donc de complexité Θ(n²).

8.2 Impl´ ementation par paires point-valeur

Un polynômeA de degré≤n−1 est représenté par un ensemble denpaires point-valeur : {(x0, y0), . . . ,(x_n−1, y_n−1)}

Exemple 23 Le polynômeA= 2+X²+5X³est représentée par l’ensemble de 4 points{(−1,−2),(0,2),(1,8),(2,46)}

(carP(−1) =−2,P(0) = 2, etc.).

Addition. En Θ(n).

Multiplication. En Θ(n), mais il faut utiliser une repr´esentation´etendue.

Ade degré≤n−1, représenté par {(x0, y0), . . . ,(x_2n−1, y_2n−1)}

B de degré≤n−1, représenté par{(x0, y⁰₀), . . . ,(x_2n−1, y_2n−1⁰ )}

alorsABde degré≤2n−1 représenté par{(x0, y0y₀⁰), . . . ,(x2n−1, y2n−1y_2n−1⁰ )}

8.3 Conversion d’une repr´ esentation ` a une autre

Repr´esentation par valeurs Multiplication

Evaluation en´ Θ(n) points distincts Avec r`egle de Horner

Interpolation

Interpolation de Lagrange

(9)

par coefficients par valeurs Evaluation en un point´ O(n) ?

Somme O(n) O(n)

Multiplication O(n²) O(n)

Evaluation en´ Θ(n) points distincts. En Θ(n²) en appliquant Θ(n) fois la r`egle de Horner.

Interpolation Trouver les coefficients du polynômes à partir des points s’appellent uneinterpolation. Cela requiert Θ(n²) opérations élémentaires si on utilise l’interpolation de Lagrange qui permet de retrouver les coefficients du polynôme à partir de couples (xi, yi) :

P

iy_i`_i(X) o`u `_i=_Π^Π^j6=i^(X−x^j⁾

j6=i(xi−xj).

8.4 Avoir le meilleur des deux mondes avec la FFT

Repr´esentation par valeurs auxnracines de l’unit´e Multiplication

Evaluation en´ Θ(n)racines de l’unit´e FFTO(nlogn)

Interpolation FFT inverseO(nlogn)

9 S´ election

Définition 24 (Problème de sélection)

• Entrée : un tableau T d’éléments comparables, un entierk ;

• Sortie : le k-ème élément le plus petit deT.

fonction selection(T, k)

Choisir un ´el´ementxdeT comme pivot

DécouperT en trois catégories : T<,T= etT> (resp. les éléments inférieurs< x, égaux à xet > x) sik≤ |T<|alors retournerselection(T<, k)

sinon si|T<|< k≤ |T<|+|T=|alors retourner x sinon retourner selection(T_>, k− |T=| − |T<|)

Théorème 25 La complexité pire cas estΘ(n²) .

9.1 Choix al´ eatoire du pivot

Choisir aléatoirement uniformément le choix du pivot jusqu’à ce que|T<| ≤3n/4 et|T>| ≤3n/4.

Théorème 26 L’espérance du temps passé pour choisir un tel pivot estO(n).

D´emonstration. On choisit un indicei du tableauT entre 1 etn. Tester que|T_<| ≤3n/4 et|T_>| ≤3n/4 se fait en tempsO(n).

On a |T<| ≤3n/4 et|T>| ≤3n/4 dès lors queiest entren/4 et 3n/4. Ainsi : P(|T<| ≤3n/4 et|T>| ≤3n/4) = 1/2 L’espéranceE du nombre de lancers jusqu’à avoir un bon choix vérifie :

(10)

E=

∞

X

j=1

j(1/2)^j Or E=P∞

j=1j(1/2)^j = 1 +P∞

j=1(j−1)(1/2)^j= 1 +P∞

j=0(j)(1/2)^j= 1 +E/2 DoncE= 2.

Donc l’esp´erance du temps pass´e est 2O(n) =O(n).

Théorème 27 L’espérance du temps passé de l’algorithme sélection avec ce choix aléatoire est O(n).

Démonstration. On a une espérance deO(n) à chaque appel récursif. En notantT(n) l’espérance du temps pour l’algorithme, on a :

T(n)≤T(3n/4) +O(n) D’o`u duT(n) =O(n).

9.2 Algorithme lin´ eaire d´ eterministe

fonctionselection(T, k)

D´ecouperT en blocs de taille 5 (sauf ´eventuellement le dernier de taille≤5)

Calculer les m´edians de chaque blocs et les stocker dans un tableauM

Calcul du tableauM.

x:=selection(M,b|M|/2c)

D´ecouperT en trois cat´egories : T<, T= et T>

si k≤ |T<|alors retournerselection(T<, k) sinon si|T<|< k≤ |T<|+|T=|alors retournerx sinon retourner selection(T_>, k− |T=| − |T<|)

Théorème 28 L’algorithme de sélection est en O(n) dans le pire cas.

Pourquoi le pivot est-il bon ?

Trions (par la pensée) les blocs par médians croissants et dessinons les chacun triés.

≤ ≤ ≤ ≤ ≤ ≤ ≤ ≤ ≤ ≤ ≤ ≤≥ ≥ ≥x ≥ ≥ ≥ ≥ ≥ ≥ ≥ ≥ ≥

D´emonstration. Le calcul du tableauM est enO(n). Le calcul du m´edian deM est enT(n/5).

Il y a 3/10 des éléments qui sont plus petits que ou égaux àx. Il y a 3/10 des éléments qui sont plus grands que ou égaux à x. Ainsi, nous avons|T<| ≤7n/10 et|T>| ≤7n/10. Ainsi la relation de récurrence est :

T(n) =T(n/5) +T(7n/10) +O(n).

Avec la méthode de l’arbre récursif (série convergente), on voit queT(n) =O(n).

10 Notes bibliographiques

Diviser pour régner est au programme de Terminale ! Ce cours a été réalisé avec les deux ouvrages phares [DPV08] et [CLRS09]. La terminologiediviser pour régner remonte à Karatsuba et Ofman [KO63] en 1963. Le tri fusion aurait

été inventé en 1945 par John von Neumann. Le tri rapide a été inventé en 1962 par Hoare [Hoa62].

L’algorithme de Strassen a fait des émois en 1969 [Str69] alors que tout le monde pensait que tout algorithme était forcément cubique dans le pire cas. Blum, Floyd, Pratt, Rivest, and Tarjan ont inventé l’algorithme de sélection en pire casO(n) [BFP⁺73]. Pour la FFT, on cite souvent Cooley et Tukey [CT65], mais l’algorithme était connu et on attribue sa première invention à Gauss.

Le papier original pour le master theorem est [BHS80]. Il y a des m´ethodes plus puissantes comme celle de Akra-Bazzi [AB98].

(11)

References

[AB98] Mohamad A. Akra and Louay Bazzi. On the solution of linear recurrence equations.Comput. Optim. Appl., 10(2):195–210, 1998.

[BFP⁺73] Manuel Blum, Robert W. Floyd, Vaughan R. Pratt, Ronald L. Rivest, and Robert Endre Tarjan. Time bounds for selection. J. Comput. Syst. Sci., 7(4):448–461, 1973.

[BHS80] Jon Louis Bentley, Dorothea Haken, and James B Saxe. A general method for solving divide-and-conquer recurrences. ACM SIGACT News, 12(3):36–44, 1980.

[CLRS09] Thomas H Cormen, Charles E Leiserson, Ronald L Rivest, and Clifford Stein. Introduction to algorithms.

MIT press, 2009.

[CT65] James W Cooley and John W Tukey. An algorithm for the machine calculation of complex fourier series.

Mathematics of computation, 19(90):297–301, 1965.

[DPV08] Sanjoy Dasgupta, Christos H. Papadimitriou, and Umesh V. Vazirani. Algorithms. McGraw-Hill, 2008.

[Hoa62] C. A. R. Hoare. Quicksort. Comput. J., 5(1):10–15, 1962.

[KO63] Anatolii Karatsuba and Yu Ofman. Multiplication of multidigit numbers on automata. In Soviet physics doklady, volume 7, pages 595–596, 1963.

[Str69] Volker Strassen. Gaussian elimination is not optimal. Numerische mathematik, 13(4):354–356, 1969.