Structure de donn´ ees avanc´ ees
Fili`ere SMI Semestre 4
Mustapha KCHIKECH
Facult´e Poly-disciplinaire Safi Universit´e Cadi Ayyad
2019-2020
D´epartement de Math´ematiques et Informatique
Chapitre 0
Introduction ` a la Complexit´ e algorithmique
Fili`ere SMI Semestre 4 Structure de donn´ees avanc´ees
1. Introduction : 1.1 Algorithme (Rappel)
Le motalgorithmeprovient du nom du math´ematicien arabe du IXe si`ecle,Mohammed Ibn-Moussa Al-Khuwarizmi(livre d’arithm´etique).
Autant dire que les algorithmes sontconnus et utilis´esbienavant les d´ebutsde l’informatique.
Premieralgorithme est l’Algorithme d’EUCLIDE (300 avant JC) pour calculer le plus grand diviseur commun de deux entiers.
Lanotion actuelled’algorithme a ´et´e ´elabor´ee par leslogiciensdes ann´ees 1930 (Herbrand,G¨odel,ChurchetTuring).
En 1968, Knuth publia lepremier ouvrageThe Art of Computer Programming sur l’´etude moderne desalgorithmes informatiques.
Il existediff´erentesfac¸ons ded´efinir un algorithme. C’est pourquoi, nous pr´esentons iciquelques d´efinitionsqui peuvent donner uneid´eesur lanotion d’algorithme.
Un algorithme est une proc´edure de calcul bien d´efinie, qui prend en entr´ee une valeur, ou un ensemble de valeurs, et qui produit, en sortie, une valeur ou un ensemble de valeurs. Un algorithme est donc une s´equence d’´etapes de calcul permettant de passer de la valeur d’entr´ee `a la valeur de sortie.
Un algorithme est une proc´edure de calcul sp´ecifique permettant d’obtenir une relation d´esir´ee entre l’entr´ee et la sortie d’un probl`eme.
L’algorithmiqueest la branche de l’informatique qui traite des algorithmes.
1. Introduction : 1.1 Algorithme (Rappel)
Exemples d’algorithmes : Algorithmes d’Euclide:
Entr´ee: deux entiers naturelsa,b Sortie: pgcd(a,b)
Calcul de puissance:
Entr´ee: deux entiers naturelsa,n Sortie: an
Algorithmes de tri:
Entr´ee: un tableau denentierstab= [a0,a1,· · ·,an−1]
Sortie: un tableau denentierstab= [b0,b1,· · ·,bn−1]t.q. b0≤b1≤ · · · ≤bn−1
Test de primalit´e :
Entr´ee: un entier natureln
Sortie: une r´eponse : n est premier oui ou non
· · ·
Fili`ere SMI Semestre 4 Structure de donn´ees avanc´ees
2. Complexit´ e des algorithmes
Motivation
Un algorithme est ditcorrect si, pour chaque donn´ee en entr´ee, il doit fournir la bonne sortie.
Dans ce cas, on dit quel’algorithme (correct)r´esoutleprobl`eme donn´e.
Pour r´esoudreinformatiquementun probl`eme donn´e, onimplantedonc un algorithme sur un ordinateur. C-`a-d, l’algorithmesera r´e´ecritavec unlangage de programmation.
Mais, pour un probl`eme donn´e, ilexistebien souventplusieursalgorithmesqui le r´esout.
Cesalgorithmesdiff`erententre eux en termes d’efficacit´e. Ces diff´erences peuvent ˆetre bienplus importantesque celles dues au mat´eriel et au logiciel.
Question
Y a-t-il un int´ erˆ et ` a choisir des algorithmes ? et si oui
comment choisir ?
2. Complexit´ e des algorithmes : 2.1 D´ efinition
Complexit´e
En informatique, la notion decomplexit´esignifiedeux concepts:
la complexit´e des algorithmes: C’est l’´etude de l’efficacit´e compar´ee des algorithmes.
En effet, lacomplexit´eintroduit la notion decoˆutet montre qu’il ne suffit pas de trouver une m´ethode correcte pour r´esoudre un probl`eme, il faut aussi que cette m´ethode soitefficace.
L’efficacit´eestmesur´eepar letempset l’espacen´ecessaire `a un algorithme pour r´esoudre un probl`eme.
La complexit´e des probl`emes: C’est l’´etude qui permetclassificationdes probl`emes en fonction desperformancesdesmeilleurs algorithmesconnus qui les r´esolvent.
Remarque
Pour notre cours, on parlera de lacomplexit´ec’est pour designer lacomplexit´e des algorithmes.
Fili`ere SMI Semestre 4 Structure de donn´ees avanc´ees
2. Complexit´ e des algorithmes : 2.2 Analyse des algorithmes
Lar´esolution informatiqued’un probl`eme donn´epassepar un algorithme qui est impl´ement´epar unlangage de programmation.
L’ex´ecutiond’un programme a uncoˆut. Il existe deux param`etres essentiels pour
´
evaluerce coˆut :
le temps d’ex´ecution : la complexit´e temporelle l’espace m´emoire requis : la complexit´e spatiale
Ainsi,analyser un algorithmeest une op´eration qui consiste `apr´evoirles ressources n´ecessaires(m´emoire, temps de calcul) au programme qui impl´ementecet algorithme.
Pour pouvoir analyser un algorithme, il faut avoir unmod`ele de la technologie qui sera employ´ee.
En algorithmique, les algorithmessont analys´esselonles calculs dans un mod`ele g´en´eriquedemachine `a acc`es al´eatoires(RAM=Random Access Machine), `a processeur unique.
Dans le mod`ele RAM, lesinstructionssont ex´ecut´ees l’une apr`es l’autre, sans op´erations simultan´ees.
En r´esum´e,
Analyse des algorithmes⇐⇒´etude de la complexit´e des algorithmes
2. Complexit´ e des algorithmes : 2.2 Analyse des algorithmes
Taille des donn´ees
Si l’on prend en compte tous les param`etres :fr´equence d’horloge,nombre de processeurs,temps d’acc`es disque,... l’estimation de ces ressources peut :
ˆ
etre assezcompliqu´ee, voireirr´ealisable,
devenirirr´ealisted`es que l’on change d’architecture.
Pour cela onse contentesouvent d’estimer l’influence dela taille des donn´ees sur la taille des ressources n´ecessaires. Ainsi,
La taille des donn´ees d´epend du probl`eme ´etudi´e
On appelle lesentr´eesou lesinstanceslataille des donn´eesn´ecessaires`a un algorithme pour r´esoudre un probl`eme donn´e.
La taillenva d´ependre ducodagede ces entr´ees
Exemple : en binaire, il fautblog2(n)c+ 1bits pour coder l’entiern.
En pratique, on choisit comme taille la ou lesdimensionsles plus significatives.
Exemple :
des matricesm×n:max(m,n),m.n,m+n
des listes, tableaux, fichiers : nombre de cases, d’´el´ements des chaˆınes de caract`eres : leur longueur
Fili`ere SMI Semestre 4 Structure de donn´ees avanc´ees
2. Complexit´ e des algorithmes : 2.2 Analyse des algorithmes
Le temps d’ex´ecution
Letemps d’ex´ecutiond’un algorithme sur une entr´ee particuli`ere est lenombre d’op´erations ´el´ementaire(affectations, comparaisons, op´erations arithm´etiques), ex´ecut´ees.
Letemps d’ex´ecutiondu programme d´epend : desdonn´eesdu probl`eme pour cette ex´ecution de laqualit´edu code engendr´e par le compilateur
de lanatureet de larapidit´e des instructionsoffertes par l’ordinateur de l’efficacit´ede l’algorithme
de l’encodagedes donn´ees
... et aussi de laqualit´e de la programmation
En g´en´eral,on ne peut pas mesurerle temps de calcul sur toutes les entr´ees possibles. Il faut trouver une autrem´ethode d’´evaluation.
L’id´eeestd’´evaluer le temps de calculen fonction d’unegrandeur n repr´esentant la taille des donn´ees.
2. Complexit´ e des algorithmes : 2.2 Analyse des algorithmes
Evaluation des coˆ´ uts
P: unprobl`emeetM:unem´ethodepourr´esoudrele probl`emeP AlgorithmeA:descriptiondeMdans unlangagedonn´e (algorithmique, C/C++, Java, ...)
Structures de contrˆole :
s´equence (suite d’instructions)
embranchement (ou s´election): if()ouswitch() boucle (ou it´eration):for(); do...while(); while()
Objectif
Evaluer le temps de calcul´ deApourP ComparerAavec un autre algorithmeA0 L’´evaluation :
d´epends de lataille du probl`eme,
doit ˆetreind´ependantede la machine utilis´ee.
Fili`ere SMI Semestre 4 Structure de donn´ees avanc´ees
2. Complexit´ e des algorithmes : 2.2 Analyse des algorithmes
Evaluation du temps de calcul´
Lacomplexit´e d’un algorithmeoul’´evaluation du temps de calcul d’un algorithmeest unemesure exprim´eeen fonction de la taillendes donn´ees :
T(n)=nombre d’op´erations ´el´ementaires On distinguetrois sortesde complexit´es :
la complexit´e dans le pire des cas:calcul du coˆut dans le pire des cas, Tpire(n) =max
n {T(n)}
la complexit´e en moyenne:on calcule le coˆut pour chaque donn´ee possible puis on divise la somme de ces coˆuts par le nombre de donn´ees diff´erentes,
Tmoyenne(n) =1n
P
n
{T(n)}
la complexit´e dans le meilleur des cas:on calcule le coˆut en se plac¸ant dans le meilleur des cas.
Tmeilleur(n) =min
n
{T(n)}
Remarque :Enanalyse de complexit´e, on´etudie souventlepire casce qui donne uneborne sup´erieurede la complexit´e de l’algorithme.
2. Complexit´ e des algorithmes : 2.2 Analyse des algorithmes
Evaluation de´ T(n) S´equence (sommes des coˆuts) :
(
TraitementT1(n)· · ·
TraitementTp(n)
⇒T(n) =T1(n) +T2(n) +· · ·+Tp(n)
Embranchement (Max des coˆuts):
si(condition logique)alors TraitementT1(n)
sinon
TraitementT2(n)
⇒T(n) = max(T1(n),T2(n))
Boucle (Somme des coˆuts de chaque passage) :
(
Tant que(condition logique)faire TraitementTi(n)Fin faire
⇒T(n) =
k
P
i
Ti(n) k=nombre de r´ep´etition du traitementTi(n).
Fili`ere SMI Semestre 4 Structure de donn´ees avanc´ees
2. Complexit´ e des algorithmes : 2.3 Notation asymptotique
Pourquoi une analyse asymptotique ?
En pratique uneanalyse pr´ecised’un algorithme mˆeme dans le pire des cas est presqueimpossible(sauf pour un algorithme simple).
La solution estd’´etabliruneapproximation asymptotiquedutemps de calculde l’algorithme. Autrement, on fait uneanalyse asymptotique.
On veutcomparerdes algorithmes diff´erents sans les impl´ementer, sans d´evelopper des programmes. Pour faire c¸a on compare l’efficacit´e asymptotique des algorithmes.
D´efinition,Θ-Notation Soientf etg deux fonctions deNdansR.
On dit queg(n)est uneborne approch´ee asymptotiquepourf(n)et l’on ´ecrit f(n)∈Θ(g(n))s’il existe deux constantesstrictement positivesc1etc2telles que, pournassez grand, on ait
0≤c1g(n)≤f(n)≤c2g(n)
Ceci revient `a dire quef(n)est ´egale `ag(n)`a un facteur constant pr`es.
Pour indiquer quef(n)∈Θ(g(n)), on ´ecrit f(n) = Θ(g(n))
2. Complexit´ e des algorithmes : 2.3 Notation asymptotique
Fili`ere SMI Semestre 4 Structure de donn´ees avanc´ees
2. Complexit´ e des algorithmes : 2.3 Notation asymptotique
D´efinition,O-Notation Soientf etg deux fonctions deNdansR.
On dit queg(n)est uneborne sup´erieure asymptotiquepourf(n)et l’on ´ecrit f(n)∈ O(g(n))s’il existe une constantestrictement positivectelle que pourn assez grandon ait
0≤f(n)≤cg(n)
Ceci revient `a dire quef(n)est inf´erieure `ag(n)`a une constante pr`es et pourn assez grand.
Pour indiquer quef(n)∈ O(g(n)), on ´ecrit f(n) =O(g(n))
2. Complexit´ e des algorithmes : 2.3 Notation asymptotique
Fili`ere SMI Semestre 4 Structure de donn´ees avanc´ees
2. Complexit´ e des algorithmes : 2.3 Notation asymptotique
Complexit´e d’un algorithme
Un algorithmeAr´esoutun probl`emePen tempsO(f(n))si pour touteinstance de taillen, l’algorithmeretourneunesolution correcteavec uncoˆutO(f(n)).
La nature de la fonctionf(n)d´efinie laclasse de complexit´ede l’algorithmeA.
Classes de complexit´e
Lors de l’analyse de complexit´e, on essaie de se ramener auxclassessuivantes : temps constant :Coˆut :O(1)Exemple : addition, affectation...
Complexit´e logarithmique:Coˆut :O(log(n))
Exemple : recherche dichotomique dans un tableau tri´eA[1...n]
Complexit´e lin´eaire:Coˆut : O(n)Exemple : calcul du produit scalaire de deux vecteurs deRn
Complexit´e quasi-lin´eaire:Coˆut :O(nlog(n)) Exemple : Tri par fusion
Complexit´e polynˆomial:Coˆut :O(nk),k>1, pourk= 2, on parle de la Complexit´e quadratiqueExemple : Multiplication de deux matrices carr´ees d’ordren: O(n3)
Complexit´e exponentielle :Coˆut :O(an)aveca>1 Exemple : Tours de Hano¨ı
2. Complexit´ e des algorithmes : 2.3 Notation asymptotique
Hi´erarchie entre les classes de complexit´e
On peut ´etablir unehi´erarchieentre lesclasses de complexit´edu pluspetitau plus grand:
O(1)→O(log(n))→O(n)→O(nlog(n))→O(n2)→O(nk)→O(an) k>2,a>1.
Comparaison :
Fili`ere SMI Semestre 4 Structure de donn´ees avanc´ees
2. Complexit´ e des algorithmes : 2.4 Exemples et Exercices
1 Quelle est lacomplexit´ede cesparties de programme?
somme=0;
for(i=1; i<=n; i++) somme += n;
——————————————- somme=0;
for (j=1; j<=n; j++) for (i=1; i<=n; i++)
somme++;
for (k=0; k<n; k++) A[k] = k;
——————————————- somme = 0;
for (i=1; i<=n; i++) for (j=1; j<=i; j++)
somme++;
——————————————- somme = 0;
for (i=1; i<=n; i*=2) for (j=1; j<=n; j++)
somme++;
2 Pour chacun des probl`emes suivants, ´ecrire enlangage Cunefonction it´erative qui permet de ler´esoudreet donner sacomplexit´e.
1 Puissance n-`eme d’un entier.
2 Tri des tableaux.
3 Test de Primalit´e d’un entier.
Complexit´ e des algorithmes : R´ ecurrence
Fili`ere SMI Semestre 4 Structure de donn´ees avanc´ees
1. Introduction et d´ efinitions
D´efinitions
Uner´ecurrenceest une´equationou unein´egalit´equi d´ecrit unefonction`a partir de sa valeur sur des entr´ees plus petites.
unefonctionestr´ecursivesi elle fait appel `a elle-mˆeme d’une mani`eredirecteou indirecte.
Un algorithme est ditr´ecursifsi sontemps de calculpeut ˆetre d´ecrit par une r´ecurrence.
Propri´et´e et remarque
L’utilisation desalgorithmes r´ecursifsest unetechnique de programmationqui permet de trouver des solutions d’une grande´el´egance`a uncertainnombre de probl`emes.
Dans unalgorithme r´ecursif, la r´ecursivit´edoit s’arrˆeter`a un moment donn´e (test d’arrˆet). Autrement, l’ex´ecution va continuerind´efiniment.
Ceprocessusest connu sous le nom duprocessus de r´eductionqui `a chaque appel, on doit se rapprocher de lacondition d’arrˆet.
Attention! : lorsqu’ellemal utilis´ee, on peut cr´eer un code de programme totalement inefficace.
1. Introduction et d´ efinitions
Exemple : Suite de Fibonacci
La suite de Fibonacci est d´efinie par :
n
u0=u1= 1un+2=un+1+un sin≥2
Unalgorithme r´ecursifqui calcule leni`eme terme de cette suite :
intfib(intn) {
if(n<=1) return1;
else
returnfib(n-1)+fib(n-2);
}
Complexit´e
SoitT(n) =nombre d’additionseffectu´ees par cet algorithme lors du calcul.
T(n)v´erifie les ´equations suivantes :
n
T(0) =T(1) = 1T(n) =T(n−2) +T(n−1) sin≥2
C’est une´equation de r´ecurrenceo`u chaque terme d’ordre≥2d´epend uniquement des 2 termes qui le pr´ec`edent.
Lasolutiondel’´equation de r´ecurrenceest
T(n) =5 +√ 5 10
1 +√ 5 2
n+5−√ 5 10
1−√ 5 2
nT(n) =O 1+
√ 5 2
n.
La complexit´e de cet algorithme est donc exponentielle ! Fili`ere SMI Semestre 4 Structure de donn´ees avanc´ees
2. R´ esolution des r´ ecurrences
Dans ce chapitre, nous allons proposertroism´ethodes der´esolutiondes r´ecurrences, c-`a-d pour obtenir desbornes asymptotiquesΘouOpour la solution.
M´ethode it´erative M´ethode de substitution M´ethode g´en´erale
2. R´ esolution des r´ ecurrences
Remarque
En pratique, quand ond´efinitetr´esout des r´ecurrences, onometsouvent les parties enti`ereset lesconditions aux limites.
En fait, cesd´etailsn’affectent paslesbornes asymptotiquesdes r´ecurrences rencontr´ees dansl’analyse des algorithmes. En effet :
Onpassesouvent sur le fait que les arguments des fonctions sont des entiers. Normalement, letemps d’ex´ecutionT(n)d’un algorithme n’est d´efinit que pournentierpuisque, dans la plupart des algorithmes, lataille de l’entr´ee a toujours unevaleur enti`ere.
Le plus souvent onignorelesconditions aux limites. Puisque letemps d’ex´ecutiond’un algorithme sur une entr´ee detaille constanteest une constante, les r´ecurrencessous-jacentesau calcul dutemps d’ex´ecution des algorithmes ont g´en´eralementT(n) = Θ(1)pournsuffisamment petit. Ainsi,pour simplifier, on suppose g´en´eralement queT(n)est constant pournpetit.
Fili`ere SMI Semestre 4 Structure de donn´ees avanc´ees
2. R´ esolution des r´ ecurrences
M´ ethode it´ erative
L’id´ ee de la m´ ethode consiste ` a d´ evelopper la r´ ecurrence en sommation.
On utilise les techniques d’´ evaluation des sommations pour trouver les bornes ` a la solution.
Cette m´ ethode n´ ecessite plus de manipulations alg´ ebriques.
2. R´ esolution des r´ ecurrences
Exemple
T(n) = 2T(n
2) + 2n+ 1
On d´eveloppe comme suit :
T(n) = 2n+ 1 + 2T(n 2)
= 2n+ 1 + 2(n+ 1 + 2T(n 4))
= 2n+ 1 + 2(n+ 1 + 2(n
2+ 1 + 2T(n 4)))
= 3(2n) + 1 + 2 + 4 + 23T(n 4)
=· · ·
= 2in+ i−1
P
j=0
2j+ 2iT(n 2i)
On arrive `aT(1)lorsque n
2i = 1,c-`a-d lorsquei=log(n).Ainsi,
T(n) = 2n log(n) + log(n)−1
P
j=0
2j+nT(1)
= 2n log(n) +n−1 +nΘ(1)
= 2n log(n) +n−1 + Θ(n) Par cons´equentT(n) =O(n log(n))
Fili`ere SMI Semestre 4 Structure de donn´ees avanc´ees
2. R´ esolution des r´ ecurrences
Un autre exemple
T(n) = 3T(n 4) +n
On d´eveloppe comme suit:
T(n) =n+ 3T(n 4)
=n+ 3(n 4+ 3T(n
42))
=n+ 3(n 4+ 3(n
42+ 3T(n 43)))
=n+3 4n+ (3
4)2n+ 33T(n 43)
=· · ·
= i−1
P
j=0 (3
4)jn+ 3iT(n 4i)
On arrive `aT(1)lorsque n
4i = 1,c-`a-d lorsquei=log4(n).Ainsi, T(n) = 4n(1−(3
4)log4 (n)) + 3log4 (n)T(1)
= 4n(1−(3
4)log4 (n)) +nlog4 (3)Θ(1) car 3log4 (n)=nlog4 (3)
= 4n+ Θ(nlog4 (3)) pour n assez grand (3
4)log4 (n)≈0 Par cons´equentT(n) =O(n)
2. R´ esolution des r´ ecurrences
M´ethode de substitution Cette m´ethode recouvredeux phases:
Onconjecturela forme de la solution : c-`a-d ondevine(parintuition) uneid´ee de la solution.
Onutiliseuner´ecurrence math´ematiquepour trouver lesconstanteset pour montrer que la solution estcorrecte.
Remarque
Lenom de cette m´ethodevient du fait que l’onsubstituela r´eponsesuppos´ee`a la fonction quand on appliquel’hypoth`ese de r´ecurrenceaux valeursplus petites.
Ellene s’appliqueque lorsquela forme de la r´eponseestfacile`a deviner.
Fili`ere SMI Semestre 4 Structure de donn´ees avanc´ees
2. R´ esolution des r´ ecurrences
Exemple
T(n) = 2T(n 2) +n
On conjecture(parintuition) que la solution estT(n) =O(n log(n)).
La m´ethode consiste `a d´emontrer queT(n)≤cn log(n)pour unchoix appropri´ede la constantec>0.
On suppose queT(n 2)≤cn
2log(n 2).
Lasubstitutiondonne
T(n) ≤2(cn 2log(n
2)) +n
≤cn log(n 2) +n
=cn log(n)−cn log(2) +n
=cn log(n)−cn+n
≤cn log(n) sic≥1
2. R´ esolution des r´ ecurrences
Remarque :Comment conjecturer les solutions des r´ecurrences ?
Malheureusement, iln’existe pasde r`egle g´en´erale.
Deviner une bonne solutionressort de l’exp´erience, c-`a-d se servir des
r´ecurrencesd´ej`a rencontr´ees. Par exemple siT(n) = 2T(n2+ 100) +n. Pourn assez grand,T(n2)etT(n2+ 100)sontquasiment les mˆemes. On peut donc supposer queT(n) =O(n log(n)).
Parfois, il suffit d’unepetite manipulation alg´ebriquepour faireresemblerune r´ecurrenceinconnue`a une autred´ej`a vue. Par exemple, on utilise un changement de variables.
Exemple : PrenonsT(n) = 2T(√
n) +log(n).
Posonsm=log(n)⇒n= 2m. On aura doncT(2m) = 2T(2m2) +m.
On poseS(m) =T(2m), on obtient une nouvelle r´ecurrence S(m) = 2S(m
2) +m⇒S(m) =O(m log(m)).
D’o`uT(n) =T(2m) =S(m) =O(m log(m)) =O(log(n)log(log(n))).
Et parfois, de l’intuition pure!!!
Fili`ere SMI Semestre 4 Structure de donn´ees avanc´ees
2. R´ esolution des r´ ecurrences
Exemple & exercice :La recherche dichotomique
V´erifier que lenombre d’it´erationde l’algorithme derecherche dichotomiqued’un tableau de taillenest
T(n) =T(n 2) + 1
Montrer que
T(n) =O(log(n))
2. R´ esolution des r´ ecurrences
M´ethode g´en´erale
Lam´ethode g´en´eraleest une m´ethode quis’appuiesur leth´eor`eme maˆıtrede la complexit´e, il est connu commeMaster theoremen anglais et on l’appelleTh´eor`eme g´en´eralen franc¸ais.
Elle est consid´er´ee comme une”recette”pour r´esoudre les r´ecurrences de la forme
T(n) =aT(n b) +f(n),
o`ua≥1etb>1sont des constantes, etf(n)une fonctionasymptotiquement positive.
Elle permet d’analyserletemps d’ex´ecutionT(n)(au pire des cas) d’un algorithme r´ecursifobtenu par l’approche ”DIVISER-POUR-R ´EGNER”.
Fili`ere SMI Semestre 4 Structure de donn´ees avanc´ees
2. R´ esolution des r´ ecurrences
M´ethode g´en´erale :”DIVISER-POUR-R ´EGNER”
L’approche”diviser-pour-r´egner”est unetechniquepour la conception des algorithmes.
En effet, un algorithme bas´e sur l’approche”diviser-pour-r´egner”
1 s´eparele probl`eme en plusieurssous-probl`emessemblablesau probl`eme initial mais detaille inf´erieure,
2 r´esolveles sous-probl`emes de fac¸onr´ecursive,
3 combinetoutes les solutions pourproduirela solution du probl`eme original.
Le principe de l’approche”diviser-pour-r´egner”se base surtrois ´etapes`a chaque niveau de r´ecursivit´e:
1 Diviser leprobl`emeen un certain nombre desous-probl`emes.
2 R´egnersur lessous-probl`emesen lesr´esolvantr´ecursivement.
Si latailled’unsous-probl`emeestassez r´eduite, on peut le r´esoudre directement.
3 Combinerlessolutionsauxsous-probl`emesen unesolution compl`etepour leprobl`eme initial.
2. R´ esolution des r´ ecurrences
”DIVISER-POUR-R ´EGNER”
Problème Solution
sous-problème 1 sous-problème 2 sous-problème j
sous-problème p
diviser régner
solution 1 solution 1 solution 1
solution 1
combiner
Problème Solution
sous-problème 1 sous-problème 2 sous-problème j
sous-problème p
diviser régner
solution 1 solution 1 solution 1
solution 1
combiner
Fili`ere SMI Semestre 4 Structure de donn´ees avanc´ees
2. R´ esolution des r´ ecurrences
Lar´ecurrencede la formeT(n) =aT(nb) +f(n),d´ecritletemps d’ex´ecution d’un algorithme quidivise un probl`emede taillenenasous-probl`emes, chacun de taille n
b.
Lesasous-probl`emessontr´esolus r´ecursivement, chacun dans un tempsT(bn).
f(n) =D(n) +C(n)repr´esente lecoˆut induitpar lad´ecomposition du probl`eme (D(n)) et lacombinaisondes r´esultats dessous-probl`emes(C(n)).
Th´eor`eme g´en´eral :
Soienta≥1etb>1deux constantes, soitf(n)une fonction et soitT(n)d´efinie pour les entiersn≥0par la r´ecurrence
T(n) =aT(n b) +f(n),
T(n)peut alors ˆetreborn´ee asymptotiquementde la fac¸on suivante.
1 Si∃ε >0t.q. f(n) =O(nlogb(a)−ε)alorsT(n) = Θ(nlogb(a)).
2 Sif(n) = Θ(nlogb(a))alorsT(n) = Θ(nlogb(a)log(n)).
3 Si∃ε >0t.q. f(n) = Ω(nlogb(a)+ε)et si∃c<1t.q. af(bn)≤cf(n), pourn suffisamment grand, alorsT(n) = Θ(f(n)).
f(n) = Ω(g(n))si∃c>0t.q. pournassez grandon ait0≤cg(n)≤f(n)
2. R´ esolution des r´ ecurrences
Signification intuitive du th´eor`eme
Dans chaque cas, oncomparela fonctionf(n)`a la fonctionnlogb(a). Lasolution de la r´ecurrenceestd´etermin´eepar laplus grande des deux.
Cas 1 : nlogb(a)est la plus grandeT(n) = Θ(nlogb(a)).
Cas 2 : f(n)est la plus grandeT(n) = Θ(f(n)).
Cas 3 : f(n) =nlogb(a),T(n) = Θ(nlogb(a)log(n)).
Remarque :
Leth´eor`eme g´en´eralne couvre pastoutes lespossibilit´espourf(n).
Fili`ere SMI Semestre 4 Structure de donn´ees avanc´ees
2. R´ esolution des r´ ecurrences
Exemple 1
T(n) = 9T(n 3) +n Pour cette r´ecurrence, on aa= 9,b= 3etf(n) =n.
On a doncnlogb(a)=nlog3(9)= Θ(n2)etf(n) =n=O(nlog3(9)−ε), avecε= 1.
D’apr`esle cas 1 du th´eor`eme g´en´eral, on peut dire queT(n) = Θ(n2).
Exemple 2
T(n) =T(2n 3 ) + 1 Pour cette r´ecurrence, on aa= 1,b=32 etf(n) = 1.
On a doncnlogb(a)=n(log32(1))=n0= 1. On est dans le cas 2 puisque f(n) = Θ(nlogb(a)) = Θ(1).
La solution de la r´ecurrence est doncT(n) = Θ(log(n)).
2. R´ esolution des r´ ecurrences
Exemple 3
T(n) = 3T(n
4) +n log(n) Pour cette r´ecurrence, on aa= 3,b= 4etf(n) =n log(n).
On a doncnlogb(a)=nlog4(3)=O(n0.793). Puisquef(n) = Ω(nlog4(3)+ε), avecε'0.2, on est dans le cas 3.
Pournsuffisamment grand,a f(n4) = 3n4log(n4)≤3n4log(n) =c f(n)avecc=34<1.
Par cons´equent, D’apr`esle cas 3, on peut dire queT(n) = Θ(n log(n)).
Exemple 4
T(n) = 2T(n
2) +n log(n)
On aa= 2,b= 2etf(n) =n log(n). On a doncnlogb(a)=nlog2(2)=n. Dans ce cas, le th´eor`eme g´en´eral ne s’applique pas `a la r´ecurrence. En effet,
On pourrais penser que le cas 3 s’applique, puisquef(n)estplus grande asymptotiquementquenlogb(a)=n. Le probl`eme est que f(n)
nlogb(a) =log(n)est asymptotiquement plus petitquenε,∀ε >0.
Fili`ere SMI Semestre 4 Structure de donn´ees avanc´ees