Introduction à la Complexté Algorithmique

(1)

la Complexté Algorithmique

Cours et exercices Filière SMI

2016-2017

Mustapha kchikech

Département de Mathématiques et Informatique

Faculté Polydsciplinaire-Safi

Université Cadi Ayyad

(2)

Introduction iii

1 Complexit´e algorithmique 1

1.1 Introduction . . . 1

1.2 Complexit´e des algorithmes . . . 2

1.2.1 Motivation . . . 2

1.2.2 Complexit´e . . . 3

1.2.3 Analyse des algorithmes . . . 3

1.2.3.1 Taille des donn´ees . . . 4

1.2.3.2 Le temps d’ex´ecution . . . 5

1.2.3.3 Evaluation des coˆ´ uts . . . 5

1.2.3.4 Objectif . . . 6

1.2.3.5 Evaluation du temps de calcul . . . .´ 6

1.2.3.6 Evaluation de T(n)´ . . . 6

1.2.4 Notation asymptotique . . . 7

1.2.4.1 Pourquoi une analyse asymptotique ? . . . 7

1.2.4.2 D´efinition Θ-Notation . . . 8

1.2.4.3 D´efinition,O-Notation . . . 9

1.2.4.4 Complexit´e d’un algorithme . . . 9

1.2.4.5 Classes de complexit´e . . . 9

1.2.4.6 Hi´erarchie entre les classes de complexit´e . . . 10

(3)

1.2.5 Exemples et exercices . . . 11

2 R´eurrence 13 2.1 Pr´esentation . . . 13

2.2 R´esolution des r´ecurrences . . . 15

2.2.1 M´ethode it´erative . . . 16

2.2.2 M´ethode de substitution . . . 18

2.2.3 Méthode générale . . . 20

2.2.4 DIVISER-POUR-R ´EGNER . . . 20

2.3 R´esolution des r´ecurrences . . . 21

2.3.1 Théorème général : . . . 22

2.3.1.1 Signification intuitive du th´eor`eme . . . 22

2.4 Exercices . . . 23

(4)

Ce polycopié présente une introduction sur la complexité algorithmique et des notions sur la récurrence en algorithmique. L’objectif est de présenter des concepts fondamentaux de la théorie de la complexité algorithmique qui offrent un ensemble d’outils permettant d’analyser, de comparer et d’optimiser des algorithmes par la suite des programmes informatique.

Par conséquent, ce document met également à la disposition des étudiants un support de cours qui pourrait leur permettre d’acquérir et d’améliorer leurs compétences en programmation.

Notons que ce document est un support p´edagogique qui s’adresse principalement aux

´

etudiants de la filière SMI semestre 4 de la Faculté Poly-disciplinaire de Safi, université cadi Ayyad. Il pourrait également servir comme support de cours aux étudiants d’autres filières.

(5)

(6)

Complexit´ e algorithmique

1.1 Introduction

— Le mot algorithme provient du nom du mathématicien arabe du IXe siècle,Mo- hammed Ibn-Moussa Al-Khuwarizmi (livre d’arithmétique).

— Autant dire que les algorithmes sont connus et utilis´es bien avant les d´ebuts de l’informatique.

— Premier algorithme est l’Algorithme d’EUCLIDE (300 avant JC) pour calculer le plus grand diviseur commun de deux entiers.

— La notion actuelle d’algorithme a été élaborée par les logiciens des années 1930 (Herbrand, Gödel, Church et Turing).

— En 1968, Knuth publia le premier ouvrage The Art of Computer Programming sur l’´etude moderne des algorithmes informatiques.

— Il existedifférentesfa¸cons dedéfinir un algorithme. C’est pourquoi, nous présentons ici quelques définitionsqui peuvent donner une idée sur la notion d’algorithme.

— Un algorithme est une procédure de calcul bien définie, qui prend en entrée 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équence d’étapes de calcul permettant de passer de la valeur d’entrée à la valeur de sortie.

(7)

— Un algorithme est une procédure de calcul spécifique permettant d’obtenir une relation désirée entre l’entrée et la sortie d’un problème.

— L’algorithmique est la branche de l’informatique qui traite des algorithmes.

Exemple 1.

— Algorithmes d’Euclide :

Entr´ee : deux entiers naturels a,b Sortie : pgcd(a,b)

— Calcul de puissance :

Entr´ee : deux entiers naturels a,n Sortie : aⁿ

— Algorithmes de tri :

Entr´ee : un tableau de n entiers tab= [a₀, a₁,· · ·, an−1]

Sortie : un tableau de n entiers tab= [b0, b1,· · ·, bn−1] t.q.b0 ≤b1 ≤ · · · ≤bn−1

— Algorithme de recherche dans un arbre binaire de recherche : Entr´ee : un arbre binaire de recherche, une valeur v

Sortie : une r´eponse :la valuer figure oui ou non dans l’arbre

— Test de primalit´e :

Entr´ee : un entier naturel n

Sortie : une r´eponse :n est premier oui ou non

— · · ·

1.2 Complexit´ e des algorithmes

1.2.1 Motivation

— Un algorithme est ditcorrect si, pour chaque donn´ee en entr´ee, il doit fournir la bonne sortie.

— Dans ce cas, on dit que l’algorithme (correct)résout leproblème donné.

— Pour résoudre informatiquement un problème donné, on implante donc un algorithme sur un ordinateur. C-à-d, l’algorithme sera réécrit avec un langage de programmation.

(8)

— Mais, pour un problème donné, il existe bien souvent plusieursalgorithmesqui le résout.

— Cesalgorithmesdiffèrent entre eux en termes d’efficacité. Ces différences peuvent ˆ

etre bien plus importantes que celles dues au mat´eriel et au logiciel.

— Y a-t-il un intérêt à choisir des algorithmes ? et si oui comment choisir ?

1.2.2 Complexit´e

En informatique, la notion decomplexit´e signifiedeux concepts:

— la complexité des algorithmes : C’est l’étude de l’efficacité comparée des algorithmes.

— En effet, la complexitéintroduit la notion decoût et montre qu’il ne suffit pas de trouver une méthode correcte pour résoudre un problème, il faut aussi que cette méthode soit efficace.

— L’efficacité est mesurée par le temps et l’espace nécessaire à un algorithme pour résoudre un problème.

— La complexité des problèmes: C’est l’étude qui permet classification des problèmes en fonction des performances des meilleurs algorithmes connus qui les résolvent.

Pour notre cours, on parlera de la complexit´e c’est pour designer la complexit´e des algorithmes.

Remarque 1.

1.2.3 Analyse des algorithmes

— Larésolution informatiqued’un problème donné passe par un algorithme qui est implémenté par un langage de programmation.

— L’exécution d’un programme a un coût. Il existe deux paramètres essentiels pour

´

evaluer ce coˆut :

— le temps d’ex´ecution :la complexit´e temporelle

(9)

— l’espace m´emoire requis : la complexit´e spatiale

— Ainsi, analyser un algorithme est une opération qui consiste à prévoir les ressources nécessaires (mémoire, temps de calcul) au programme qui implémente cet algorithme.

— Pour pouvoir analyser un algorithme, il faut avoir un mod`ele de la technologie qui sera employ´ee.

— En algorithmique, les algorithmes sont analysés selonles calculs dans un modèle génériquedemachine à accès aléatoires (RAM=Random Access Machine), à pro- cesseur unique.

— Dans le modèle RAM, les instructions sont exécutées l’une après l’autre, sans opérations simultanées.

— En r´esum´e,

Analyse des algorithmes⇐⇒´etude de la complexit´e des algorithmes

1.2.3.1 Taille des donn´ees

Si l’on prend en compte tous les paramètres : fréquence d’horloge, nombre de proces- seurs, temps d’accès disque,... l’estimation de ces ressources peut :

— être assez compliquée, voire irréalisable,

— devenir irr´ealiste d`es que l’on change d’architecture.

— Pour cela on se contente souvent d’estimer l’influence de la taille des donn´ees sur la taille des ressources n´ecessaires. Ainsi,

La taille des données dépend du problème étudié

— On appelle les entrées ou les instances lataille des donnéesnécessaires à un algorithme pour résoudre un problème donné.

— La taille nva d´ependre du codage de ces entr´ees

Exemple :en binaire, il fautblog₂(n)c+ 1bits pour coder l’entier n.

— En pratique, on choisit comme taille la ou les dimensions les plus significatives.

— Exemple :

(10)

— des matrices m×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

1.2.3.2 Le temps d’ex´ecution

— Le temps d’exécution d’un algorithme sur une entrée particulière est le nombre d’opérations élémentaire (affectations, comparaisons, opérations arithmétiques), exécutées.

— Le temps d’ex´ecution du programme d´epend :

— des données du problème pour cette exécution

— de la qualit´e du code engendr´e par le compilateur

— de la nature et de la rapidit´e des instructions offertes par l’ordinateur

— de l’efficacit´e de l’algorithme

— de l’encodage des donn´ees

— ... et aussi de la qualit´e de la programmation

— En général, on ne peut pas mesurer le temps de calcul sur toutes les entrées possibles. Il faut trouver une autre méthode d’évaluation.

— L’idée estd’évaluer le temps de calculen fonction d’unegrandeur nreprésentant la taille des données.

1.2.3.3 Evaluation des coˆ´ uts

— P :unproblèmeetM:une méthodepour résoudre le problème P

— AlgorithmeA:descriptiondeMdans un langage donn´e (algorithmique, C/C++, Java, ...)

— Structures de contrˆole :

— s´equence (suite d’instructions)

— embranchement (ou s´election) : if()ou switch()

— boucle (ou it´eration) : for(); do...while(); while()

(11)

1.2.3.4 Objectif

— Evaluer le temps de calcul´ de A pourP

— ComparerA avec un autre algorithmeA⁰

— L’´evaluation :

— d´epends de la taille du probl`eme,

— doit être indépendante de la machine utilisée.

1.2.3.5 Evaluation du temps de calcul´

— Lacomplexité d’un algorithmeoul’évaluation du temps de calcul d’un algorithme est unemesure expriméeen fonction de la taille n des données :

T(n)=nombre d’opérations élémentaires

— On distingue trois sortes de 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é en moyenne : on calcule le coût pour chaque donnée possible puis on divise la somme de ces coûts par le nombre de données différentes,

T_moyenne(n) =_n¹ P

n

{T(n)}

— la complexit´e dans le meilleur des cas :on calcule le coˆut en se pla¸cant dans le meilleur des cas.

Tmeilleur(n) =min

n {T(n)}

— Remarque : Enanalyse de complexité, on étudie souvent lepire casce qui donne une borne supérieure de la complexité de l’algorithme.

1.2.3.6 Evaluation de T(n)´

— S´equence (sommes des coˆuts) : Exemple 2.

(12)











TraitementT1(n)

· · ·

TraitementTp(n)

⇒T(n) =T₁(n) +T₂(n) +· · ·+T_p(n)

— Embranchement (Max des coˆuts) : Exemple 3.











si(condition logique) alors TraitementT1(n)

sinon

TraitementT2(n)

⇒T(n) = max(T₁(n), T₂(n))

— Boucle (Somme des coˆuts de chaque passage) : Exemple 4.











Tant que (condition logique) faire TraitementT_i(n)

Fin faire

⇒T(n) =

k

P

i

T_i(n)

k=nombre de r´ep´etition du traitement Ti(n).

1.2.4 Notation asymptotique

1.2.4.1 Pourquoi une analyse asymptotique ?

— En pratique une analyse pr´ecise d’un algorithme mˆeme dans le pire des cas est presque impossible (sauf pour un algorithme simple).

— La solution est d’´etablir uneapproximation asymptotique du temps de calcul de l’algorithme. Autrement, on fait une analyse asymptotique.

— On veut comparer des algorithmes différents sans les implémenter, sans développer des programmes. Pour faire ¸ca on compare l’efficacité asymptotique des algorithmes.

(13)

1.2.4.2 D´efinition Θ-Notation

Soient f etg deux fonctions deNdansR.

— On dit que g(n) est une borne approch´ee asymptotique pour f(n) et l’on ´ecrit f(n)∈Θ(g(n)) s’il existe deux constantes strictement positivesc1 etc2 telles que, pourn assez grand, on ait

0≤c₁g(n)≤f(n)≤c₂g(n)

— Ceci revient à dire que f(n) est égale àg(n) à un facteur constant près.

— Pour indiquer quef(n)∈Θ(g(n)), on ´ecrit f(n) = Θ(g(n))

Exemple 5.

— Montrons quef(n) = ¹₂n²−3n= Θ(n²).

— On doit trouver c₁, c₂, n₀>0 telles que

(14)

pour tout n≥n0

c₁n² ≤ ¹₂n²−3n ≤ c₂n² c₁ ≤ ¹₂ −_n³ ≤ c₂

Prenons c₂= ¹₂, on a

∀n≥1, 1 2 − 3

n ≤c₂ Prenons c1 = ₁₄¹ , on a

∀n≥7, c1≤ 1 2 − 3

n On prend donc n₀ = 7, c₁ = ₁₄¹ etc₂ = ¹₂.

1.2.4.3 D´efinition, O-Notation

Soientf etg deux fonctions deNdansR.

— On dit que g(n) est une borne sup´erieure asymptotique pour f(n) et l’on ´ecrit f(n) ∈ O(g(n)) s’il existe une constante strictement positive c telle que pour n assez grand on ait

0≤f(n)≤cg(n)

— Ceci revient à dire que f(n) est inférieure à g(n) à une constante près et pourn assez grand.

— Pour indiquer quef(n)∈ O(g(n)), on ´ecrit f(n) =O(g(n))

1.2.4.4 Complexit´e d’un algorithme

— Un algorithmeArésout un problème P en temps O(f(n))si pour toute instance de taille n, l’algorithme retourne unesolution correcte avec un coût O(f(n)).

— La nature de la fonctionf(n) d´efinie la classe de complexit´e de l’algorithme A.

1.2.4.5 Classes de complexit´e

Lors de l’analyse de complexit´e, on essaie de se ramener aux classes suivantes :

(15)

— temps constant :Coˆut : O(1) Exemple : addition, affectation...

— Complexit´e logarithmique : Coˆut : O(log(n))

Exemple : recherche dichotomique dans un tableau tri´e A[1...n]

— Complexité linéaire : Coût : O(n) Exemple : calcul du produit scalaire de deux vecteurs deRⁿ

— Complexité quasi-linéaire : Coût :O(nlog(n)) Exemple : Tri par fusion

— Complexité polynômial : Coût : O(n^k),k > 1, pour k = 2, on parle de la Com- plexité quadratique Exemple : Multiplication de deux matrices carrées d’ordren: O(n³)

— Complexit´e exponentielle : Coˆut : O(aⁿ) avec a >1 Exemple : Tours de Hano¨ı

1.2.4.6 Hi´erarchie entre les classes de complexit´e

On peut établir une hiérarchie entre les classes de complexité du plus petit au plus grand:

— O(1)→O(log(n))→O(n)→O(nlog(n))→O(n²)→O(n^k)→O(aⁿ)

(16)

k >2,a >1.

— Comparaison :

1.2.5 Exemples et exercices

1. Quelle est lacomplexit´ede ces parties de programme? somme=0;

for(i=1; i<=n; i++) somme += n;

——————————————-

somme=0;

for (j=1; j<=n; j++)

a for (i=1; i<=n; i++) a somme++;

for (k=0; k<n; k++) a A[k] = k;

——————————————-

somme = 0;

for (i=1; i<=n; i++)

a for (j=1; j<=i; j++) somme++;

(17)

——————————————-

somme = 0;

for (i=1; i<=n; i*=2) a for (j=1; j<=n; j++) a somme++;

2. Pour chacun des problèmes suivants, écrire en langage C une fonction itérative qui permet de le résoudreet donner sa complexité.

(a) Puissance n-`eme d’un entier.

(b) Suite de Fibonacci.

(c) Tri des tableaux.

(d) Test de Primalit´e d’un entier.

(18)

R´ eurrence

2.1 Pr´ esentation

— Une récurrence est une équation ou une inégalité qui décrit une fonction à partir de sa valeur sur des entrées plus petites.

— une fonction est récursive si elle fait appel à elle-même d’une manière directe ou indirecte.

— Un algorithme est dit récursif si son temps de calcul peut être décrit par une récurrence.

(19)

— L’utilisation des algorithmes récursifs est une technique de programmation qui permet de trouver des solutions d’une grande élégance à un certain nombre de problèmes.

— Dans un algorithme récursif, la récursivité doit s’arrêter à un moment donné (test d’arrêt). Autrement, l’exécution va continuer indéfiniment.

— Ce processus est connu sous le nom du processus de réduction qui à chaque appel, on doit se rapprocher de la condition d’arrêt.

— Attention !: lorsqu’elle mal utilis´ee, on peut cr´eer un code de programme totalement inefficace.

Remarque 2.

Suite de Fibonacci

— La suite de Fibonacci est d´efinie par :







u₀ =u₁ = 1

un+2=un+1+un si n≥2

— Un algorithme r´ecursif qui calcule leni`eme terme de cette suite : int fib(int n)

{

a if(n<=1) a return 1;

a else

a return fib(n-1)+fib(n-2);

}

— Complexit´e :

— SoitT(n) =nombre d’additions effectu´ees par cet algorithme lors du calcul.

— T(n) v´erifie les ´equations suivantes :

(20)







T(0) =T(1) = 1

T(n) =T(n−2) +T(n−1) sin≥2

— C’est une équation de récurrence où chaque terme d’ordre≥2 dépend unique- ment des 2 termes qui le précèdent.

— La solution de l’´equation de r´ecurrence est

T(n) = 5 +√ 5 10

1 +√ 5 2

n

+5−√ 5 10

1−√ 5 2

n

— T(n) =O ¹⁺

√ 5 2

n .

— La complexit´e de cet algorithme est donc exponentielle !

2.2 R´ esolution des r´ ecurrences

Dans ce chapitre, nous allons proposer trois méthodes de résolution des récurrences, c-à-d pour obtenir des bornes asymptotiques Θ ouO pour la solution.

— M´ethode it´erative

— M´ethode de substitution

— Méthode générale

(21)

— En pratique, quand ondéfinitetrésout des récurrences, on omet souvent les parties entières et les conditions aux limites.

— En fait, ces détails n’affectent pas les bornes asymptotiques des récurrences rencontrées dans l’analyse des algorithmes. En effet :

— On passe souvent sur le fait que les arguments des fonctions sont des entiers. Normalement, le temps d’exécutionT(n)d’un algorithme n’est définit que pour n entier puisque, dans la plupart des algorithmes, la taille de l’entrée a toujours une valeur entière.

— Le plus souvent on ignore les conditions aux limites. Puisque le temps d’exécutiond’un algorithme sur une entrée de taille constante est une constante, les récurrences sous-jacentes au calcul du temps d’exécution des algorithmes ont généralement T(n) = Θ(1) pour n suffisamment petit. Ainsi, pour simplifier, on suppose généralement queT(n) est constant pourn petit.

Remarque 3.

2.2.1 M´ethode it´erative

— L’idéede la méthode consiste à développer la récurrenceen sommation.

— On utilise les techniques d’´evaluation des sommations pour trouver les bornes `a la solution.

— Cette méthode nécessite plus de manipulations algébriques.

Exemple 6.

T(n) = 2T(n

2) + 2n+ 1

(22)

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 + 2³T(n 4)

=· · ·

= 2in+

i−1

P

j=0

2^j + 2ⁱT(n 2ⁱ) On arrive `a T(1) lorsque n

2ⁱ = 1,c-`a-d lorsque i=log(n).Ainsi, T(n) = 2n log(n) +

log(n)−1

P

j=0

2^j+nT(1)

= 2n log(n) +n−1 +nΘ(1)

= 2n log(n) +n−1 + Θ(n) Par cons´equentT(n) =O(n log(n))

Exemple 7.

T(n) = 3T(n 4) +n

On d´eveloppe comme suit:

T(n) =n+ 3T(n 4)

=n+ 3(n

4 + 3T(n 4²))

=n+ 3(n

4 + 3(n

4² + 3T(n 4³)))

=n+3 4n+ (3

4)²n+ 3³T(n 4³)

=· · ·

=

i−1

P

j=0

(3

4)^jn+ 3ⁱT(n 4ⁱ)

(23)

On arrive `a T(1) lorsque n

4ⁱ = 1, c-`a-d lorsque i=log₄(n). Ainsi, T(n) = 4n(1−(3

4)^log⁴⁽ⁿ⁾) + 3^log⁴⁽ⁿ⁾T(1)

= 4n(1−(3

4)^log⁴⁽ⁿ⁾) +n^log⁴⁽³⁾Θ(1) car 3^log⁴⁽ⁿ⁾=n^log⁴⁽³⁾

= 4n+ Θ(n^log⁴⁽³⁾) pour n assez grand (3

4)^log⁴⁽ⁿ⁾≈0 Par cons´equent T(n) =O(n)

2.2.2 M´ethode de substitution Cette m´ethode recouvre deux phases :

— On conjecture la forme de la solution : c-`a-d on devine (par intuition) une id´ee de la solution.

— On utilise une r´ecurrence math´ematique pour trouver les constantes et pour montrer que la solution est correcte.

— Le nom de cette méthode vient du fait que l’on substitue la réponse supposée à la fonction quand on appliquel’hypothèse de récurrence aux valeurs plus petites.

— Elle ne s’applique que lorsquela forme de la r´eponseest facile `a deviner.

Remarque 4.

Exemple 8.

T(n) = 2T(n 2) +n

On conjecture (par intuition) que la solution est T(n) =O(n log(n)).

La méthode consiste à démontrer que T(n) ≤ cn log(n) pour un choix approprié de la constante c >0.

On suppose que T(n 2)≤cn

2 log(n 2).

La substitution donne

(24)

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

Comment conjecturer les solutions des r´ecurrences ?

— Malheureusement, il n’existe pas de règle générale.

— Deviner une bonne solution ressort de l’expérience, c-à-d se servir des récurrences déjà rencontrées. Par exemple si T(n) = 2T(ⁿ₂ + 100) +n.

Pour n assez grand,T(ⁿ₂) etT(ⁿ₂ + 100) sont quasiment les mˆemes. On peut donc supposer queT(n) =O(n log(n)).

— Parfois, il suffit d’une petite manipulation algébrique pour faire resembler une récurrence inconnue à une autre déjà vue. Par exemple, on utilise un changement de variables.

Exemple :PrenonsT(n) = 2T(√

n) +log(n).

Posonsm=log(n) ⇒ n= 2^m. On aura doncT(2^m) = 2T(2^m² ) +m.

On poseS(m) =T(2^m), on obtient une nouvelle r´ecurrence S(m) = 2S(m

2) +m⇒ S(m) =O(m log(m)).

D’o`u T(n) =T(2^m) =S(m) =O(m log(m)) =O(log(n)log(log(n))).

— Et parfois, de l’intuition pure ! ! ! Remarque 5.

Exemple & exercice : La recherche dichotomique

— V´erifier que lenombre d’it´erationde l’algorithme derecherche dichotomiqued’un tableau de taille n est

T(n) =T(n 2) + 1

(25)

— Montrer que

T(n) =O(log(n))

2.2.3 Méthode générale

La méthode générale est une méthode qui s’appuie sur le théorème maˆıtre de la complexité, il est connu comme Master theorem en anglais et on l’appelle Théorème général en fran¸cais.

— Elle est considérée comme une ”recette” pour résoudre les récurrences de la forme

T(n) =aT(n

b) +f(n),

o`u a ≥1 et b > 1 sont des constantes, et f(n) une fonction asymptotiquement positive.

— Elle permet d’analyser letemps d’exécutionT(n)(au pire des cas) d’un algorithme récursif obtenu par l’approche ”DIVISER-POUR-R ÉGNER”.

2.2.4 DIVISER-POUR-R´EGNER

— L’approche ”diviser-pour-r´egner”est une technique pour la conception des algorithmes.

— En effet, un algorithme bas´e sur l’approche”diviser-pour-r´egner”

1. sépare le problème en plusieurs sous-problèmessemblablesau problème initial mais de taille inférieure,

2. résolve les sous-problèmes de fa¸con récursive,

3. combine toutes les solutions pour produire la solution du probl`eme original.

— Le principe de l’approche ”diviser-pour-régner”se base sur trois étapesà chaque niveau de récursivité :

1. Diviser leprobl`eme en un certain nombre desous-probl`emes.

(26)

2. Régnersur lessous-problèmesen les résolvant récursivement.

Si la taille d’un sous-problème est assez réduite, on peut le résoudre directe- ment.

3. Combiner les solutions aux sous-problèmes en une solution complète pour le problème initial.

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

2.3 R´ esolution des r´ ecurrences

— La récurrence de la forme T(n) =aT(ⁿ_b) +f(n),décritletemps d’exécutiond’un algorithme quidivise un problèmede taillenenasous-problèmes, chacun de taille

n b.

— Les asous-problèmessont résolus récursivement, chacun dans un temps T(ⁿ_b).

— f(n) =D(n) +C(n) représente lecoût induitpar la décomposition du problème (D(n)) et lacombinaison des résultats des sous-problèmes(C(n)).

(27)

2.3.1 Théorème général :

Soienta≥1 etb >1 deux constantes, soitf(n) une fonction et soitT(n) d´efinie pour les entiers n≥0 par la r´ecurrence

T(n) =aT(n

b) +f(n),

T(n) peut alors ˆetre born´ee asymptotiquement de la fa¸con suivante.

1. Si∃ε >0t.q. f(n) =O(n^log^b^(a)−ε)alors T(n) = Θ(n^log^b^(a)).

2. Sif(n) = Θ(n^log^b^(a)) alors T(n) = Θ(n^log^b^(a)log(n)).

3. Si∃ε >0 t.q.f(n) = Ω(n^log^b^(a)+ε) et si∃c < 1t.q. af(ⁿ_b)≤cf(n), pour nsuffisamment grand, alorsT(n) = Θ(f(n)).

f(n) = Ω(g(n))si∃c >0t.q. pournassez grandon ait0≤cg(n)≤f(n) Th´eor`eme 1.

2.3.1.1 Signification intuitive du th´eor`eme

Dans chaque cas, on compare la fonctionf(n) à la fonctionn^log^b^(a). La solution de la récurrence est déterminée par la plus grande des deux.

— Cas 1 :n^log^b^(a) est la plus grandeT(n) = Θ(n^log^b^(a)).

— Cas 2 :f(n) est la plus grande T(n) = Θ(f(n)).

— Cas 3 :f(n) =n^log^b^(a),T(n) = Θ(n^log^b^(a)log(n)).

Le théorème général ne couvre pastoutes les possibilitéspour f(n).

Remarque 6.

Exemple 9.

T(n) = 9T(n 3) +n

(28)

Pour cette r´ecurrence, on a a= 9,b= 3 et f(n) =n.

On a donc n^log^b^(a)=n^log³⁽⁹⁾= Θ(n²) etf(n) =n=O(n^log³^(9)−ε), avec ε= 1.

D’après le cas 1 du théorème général, on peut dire que T(n) = Θ(n²).

Exemple 10.

T(n) =T(2n 3 ) + 1 Pour cette r´ecurrence, on a a= 1,b= ³₂ et f(n) = 1.

On a donc n^log^b^(a) = n^(log³²⁽¹⁾⁾ = n⁰ = 1. On est dans le cas 2 puisque f(n) = Θ(n^log^b^(a)) = Θ(1).

La solution de la r´ecurrence est doncT(n) = Θ(log(n)).

Exemple 11.

T(n) = 3T(n

4) +n log(n) Pour cette r´ecurrence, on a a= 3,b= 4 et f(n) =n log(n).

On a donc n^log^b^(a)=n^log⁴⁽³⁾=O(n^0.793). Puisque f(n) = Ω(n^log⁴^(3)+ε), avec ε'0.2, on est dans le cas 3.

Pour n suffisamment grand, a f(ⁿ₄) = 3ⁿ₄log(ⁿ₄)≤3ⁿ₄ log(n) =c f(n) avec c= ³₄ <1.

Par cons´equent, D’apr`es le cas 3, on peut dire queT(n) = Θ(n log(n)).

Exemple 12.

T(n) = 2T(n

2) +n log(n)

On aa= 2, b= 2 et f(n) =n log(n). On a donc n^log^b^(a)=n^log²⁽²⁾=n. Dans ce cas, le théorème général ne s’applique pas à la récurrence. En effet,

On pourrais penser que le cas 3 s’applique, puisque f(n) est plus grande asymptotiquement que n^log^b^(a) =n. Le probl`eme est que ^f⁽ⁿ⁾

n^logb^(a) =log(n) est asymptotiquement plus petit que n^ε, ∀ε >0.

2.4 Exercices

Exercice 1 :

(29)

Pour chacune des fonctions suivantes, d´eterminer le temps de calcul dans le pire des cas et enO() en justifiant votre r´eponse :

1. int fonct1(int n) 2. int fonct2(int n)

{ {

int i,j,s=0; int i,j,s=n;

for(j=30;j>10;j--) for(i=200;i>100;i-=20) for(i=n/2;i>0;i-=2) for(j=n;j>=n-4;j-=2)

s*=2; s/=2;

return s; return s;

} }

{ {

int i,j=1,s=0; int i=0,j,s=0;

while(j<n) do

{ {j=i++;

for(i=1;i<n*n;i*=2) while(j<2*i)

s++; {

j++; s++;

} j+=3;

return s; }

} }while(i<n);

return s;

}

{ {

if(n==0) if(n==0)

return 1; return 1;

return 2*fonct5(n/4); return fonct6(n-1)+fonct6(n-1);

} }

Exercice 2 :

1. Donner la complexit´e des algorithmes it´eratifs suivants :

(30)

(a) Ajouter un élément en tête, fin et quelconque, d’une liste chaˆınée.

(b) Supprimer un élément en tête, fin et quelconque, liste chaˆınée.

(c) Rechercher un élément quelconque dans une liste chaˆınée.

2. Évaluer la complexité des méthodes itératives proposées pour (a) calculer la puissancenième d’un entier,

(b) trier (selection, bulle, insertion) un tableau (ou une liste), (c) calculer leni`eme terme de la suite de Fibonacci,

(d) effectuer la recherche dichotomique dans une table,

(e) parcourir un arbre binaire et rechercher un ´el´ement dans un arbre binaire AVL.

Exercice 3 :

1. Donnez des bornes asymptotiques approch´ees pourT(n) dans chacun des r´ecurrences suivantes :

(a) T(n) = 4T(ⁿ₂) +n.

(b) T(n) = 4T(ⁿ₂) +n³. (c) T(n) = 2T(ⁿ₂) +√

n.

(d) T(n) =√ nT(√

n) +n.

2. Le temps d’exécution d’un algorithmeA₁ résolvant un problèmeP est décrit par la récurrence T1(n) = 7T1(ⁿ₂) +n². Un autre algorithme A₂ résolvant le même problèmeP a un temps d’exécution décrit parT₂(n) =αT₂(ⁿ₄) +n². Quelle est la plus grande valeur deα telle queA₂ soit asymptotiquement plus rapide queA₁? 3. Soit une fonction définie par :

int fonct(int n) {

if(n<2) return 1;

else return 4*fonct(n-1)-2*fonct(n-2);

}

(31)

(a) Soit T(n) le temps d’ex´ecution de la fonction fonct(). Exprimer T(n) en fonction deT(n−1) etT(n−2).

(b) Calculer la complexit´e dans le pire des cas et en O() de cette fonction. Ce programme est-il efficace ?

(c) Proposer une autre fonction en O(n) pour effectuer le mˆeme traitement.

Exercice 5 :

1. Donner la complexité des algorithmes récursifs suivants : (a) Supprimer un élément quelconque dans une liste chaˆınée.

(b) Rechercher un élément quelconque dans une liste chaˆınée.

(c) calculer la puissanceni`eme d’un entier,

(d) trier (fusion, rapide, tas) un tableau (ou une liste), (e) calculer le ni`eme terme de la suite de Fibonacci, (f) effectuer la recherche dichotomique dans une table.

2. Évaluer la complexité des différents algorithmes récursifs, vus au cours et en TD, traitant les arbres binaires.

Exercice 4 :

Le tri fusion est une méthode algorithmique basée sur la technique ”diviser pour régner”. Le principe de cette méthode peut être décrit par l’algorithme récursif suivant :

— On divise la liste en deux parties presque de mˆeme tailles,

— On trie les deux parties,

— On fusionne les deux parties.

Ce processus de la récursivité s’arrête une fois la décomposition des sous-listes donnent des sous-listes composées d’un seul élément et le tri est alors trivial.

1. Écrire une fonction de prototype liste diviseListe(liste l) qui permet de diviser une liste chaˆınée en deux sous-liste. Calculer sa complexité en fonction de la taille de la liste d’entrée.

(32)

2. ´Ecrire une fonction de prototype liste FusionListe(liste lG,liste lD) qui permet de fusionner deux listes. Calculer sa complexit´e.

3. Écrire une fonction de prototype void triFusionListe(liste *l) qui permet de trier une liste chaˆınée d’entiers. Calculer sa complexité en fonction de la taille de la liste d’entrée.