Cours Complexité Algorithmique

Cours Complexité Algorithmique
Chapitre 1: introduction au
complexité algorithmique
Outline
1 Algorithmique
2 Temps d’exécution
3 Complexité algorithmique
Cours Complexité Algorithmique 2 / 36

Algorithmique introduction
Algorithmique
L’objet de ce cours est l’algorithmique

L’algorithmique est l’étude des algorithmes
Un algorithme est une méthode permettant de résoudre un
problème donné en un temps fini
Cours Complexité Algorithmique 2016

Methodologie
Il n’existe pas d’algorithme pour créer des algorithmes

Il existe quelques principes généraux que l’on peut suivre
Ce cours a pour objectif d’acquérir ces principes

Du raisonnement à l’algorithme puis au code
Exemple de tache : décider si un tableau L est trié en ordre croissant

Raisonnement: Un tableau L est trié si tous ses éléments sont
dans l’ordre croissant
Plus formellement : L trié ⇐ ⇒ ∀i0 < i < |L| L[i] < L[i + 1]
5

Algo: Une fonction vérifiant cette propriété supposera donc le
tableau trié au départ, et cherchera une contradiction
5
Cours Complexité Algorithmique 2016 5 / 36

Algo: Une fonction vérifiant cette propriété supposera donc le
tableau trié au départ, et cherchera une contradiction
code:
boolean trie(L)
for(i=0;i<L.lengh();i++)
if L[i] > L[i + 1] return False
return True
5
Algorithmique objectifs
Objectifs
On attend d’un algorithme qu’il résolve de manière efficace le

problème à résoudre, quelles que soient les données à
traiter
On s’intéresse principalement à deux aspects d’un algorithme

donnée :
sa correction : résout-il bien le problème donnée ?
son efficacité : en combien de temps et avec quelles ressources ?

Efficacité
L’efficacité d’un algorithme peut etre évaluée par:

rapidité (en termes de temps d’exécution)
consommation de ressources (espace de stockage, mémoire
utilisée)
7
Efficacité
L’efficacité d’un algorithme peut etre évaluée par:

rapidité (en termes de temps d’exécution)
consommation de ressources (espace de stockage, mémoire
utilisée)
La théorie de complexité étudie l’efficacité des algorithmes
7
Théorie de la complexité
La théorie de la complexité vise à répondre aux besoins

d’efficacité des algorithmes(programme)
8
Théorie de la complexité
La théorie de la complexité vise à répondre aux besoins

d’efficacité des algorithmes(programme)
Elle permet :
de classer les problèmes selon leur difficulté
de classer les algorithmes selon leur efficacité
de comparer les algorithmes résolvant un problème donné afin de
faire un choix éclairé sans devoir les implémenter
8
Temps d’exécution
Evaluation de la rapidité d’un algorithme
On ne mesure pas la durée en heures, minutes, secondes,...

cela impliquerait d’implémenter les algorithmes qu’on veut
comparer
9

comparer
de plus, ces mesures ne seraient pas pertinentes car le même
algorithme sera plus rapide sur une machine plus puissante
9

comparer
de plus, ces mesures ne seraient pas pertinentes car le même
algorithme sera plus rapide sur une machine plus puissante
Au lieu de ca, on utilise des unités de temps abstraites

proportionnelles au nombre d’opérations effectuées
Au besoin, on pourra ensuite adapter ces quantités en fonction de
la machine sur laquelle l’algorithme s’exécute
9
Calcul du temps d’exécution
Règles:
Chaque instruction basique consomme une unité de temps
(affectation d’une variable, comparaison,...)
10
Règles:
Chaque itération d’une boucle rajoute le nombre d’unités
de temps consommées dans le corps de cette boucle
10
Règles:
Chaque appel de fonction rajoute le nombre d’unités de
temps consommées dans cette fonction
10
Règles:
Chaque appel de fonction rajoute le nombre d’unités de temps
consommées dans cette fonction
Pour avoir le nombre d’opérations effectuées par l’algorithme, on
additionne le tout
10
Temps de calcul d’une fonction Factorielle
L’algorithme suivant calcule n! = n ∗(n − 1) ∗(n − 2) ∗.... ∗1 avec 0! = 1

int factorielle(n)
fact = 1;
i = 2;
while (i <= n)
fact = fact * i;
i = i + 1;
return fact


int factorielle(n)
fact = 1; initialisation(1)
i = 2; affectation (1)
while (i <= n) comparaison (1)

fact = fact * i; aff. + multip.(2)
i = i + 1; affectation + addition (2)
return fact retour (1)
12

int factorielle(n)
fact = 1; initialisation(1)
i = 2; affectation (1)
while (i <= n) comparaison (1)

fact = fact * i; aff. + multip.(2)
i = i + 1; affectation + addition (2)
return fact retour (1)
Temps de calcul= 1+1 + (2+2+1)*(n-1)+1+1 = 5n-1 opérations
12
Temps de Calcul exacte
on peut calculer le temps de calcul exacte sur la machine

Exemple en JAVA:
int factorielle(n)
long deb=System.nanoTime();
fact = 1;
i = 2;
while (i <= n)
fact = fact * i;
i = i + 1;
long fin=System.nanoTime();
long temps=fin-deb;
System.out.println(temps);
return fact
13
Problèmes
Unités de temps abstraites

depend des données
depend de la nature des données(variables): on ne sait pas toujours combien de
fois exactement on va effectuer une boucle
De même, lors d’un branchement conditionnel, le nombre de comparaisons
effectuées n’est pas toujours le même
Temps exacte
depend de la puissance de la machine
depend de la nature des données(variables): si on change les données, le
temps change

Complexité algorithmique
La complexité d’un algorithme est une mesure de sa performance asymptoptique

dans le pire cas
que signifie asymtotique ?

on s’intéresse à des données très grandes
pourquoi ?
les petites valeurs ne sont pas assez informatives
Que signifie "dans le pire cas" ?

on s’intéresse à la performance de l’algorithme dans les situations où le
problème prend le plus de temps à résoudre
pourquoi ?
on veut être sûr que l’algorithme ne prendra jamais plus de temps que ce qu’on
a estimé

Comparaison du temps de calcul
Soit un problème à résoudre sur des données de taille n, et

Deux algorithmes résolvant ce problème en un temps f 1(n) etf 2(n)
Quel algorithme préférez-vous ?
16
Comparaison du temps de calcul
Soit un problème à résoudre sur des données de taille n, et

Deux algorithmes résolvant ce problème en un temps f 1(n) etf 2(n)
Quel algorithme préférez-vous ?
16
Passage à la complexité asymptotique
De plus, le degré de précision qu’ils requièrent est souvent inutile

On aura donc recours à une approximation de ce temps de calcul, représentée
par la notation O(.)

Notations asymptotiques
Soit n la taille des données à traiter, on dit qu’une fonction f (n) est en O(g(n)) si :
∃n 0 ∈ N , ∃c ∈ R , ∀n >= n 0 : |f (n)| <= c|g(n)|
f (n) est en O(g(n)) s’il existe un seuil à partir duquel la fonction f (.) est
toujours dominée par la fonction g(.), à une constante multiplicative fixée près ;
18
Notations asymptotiques
Soit n la taille des données à traiter, on dit qu’une fonction f (n) est en O(g(n)) si :
∃n 0 ∈ N , ∃c ∈ R , ∀n >= n 0 : |f (n)| <= c|g(n)|
f (n) est en O(g(n)) s’il existe un seuil à partir duquel la fonction f (.) est
toujours dominée par la fonction g(.), à une constante multiplicative fixée près ;
Exemples: quelques cas où f (n) = O(g(n))
18
Exemple de calcul de O(.)
Prouvons que la fonction f 1 (n) = 5n + 37 est en O(n) :
19

but : trouver une constante c ∈ R et un seuil n 0 ∈ N à partir duquel
|f 1 (n 0 )| <= c|n 0 | .
19

but : trouver une constante c ∈ R et un seuil n 0 ∈ N à partir duquel
|f 1 (n 0 )| <= c|n 0 | .
on remarque que |5n + 37| <= |6n| si n >= 37
on déduit donc que c = 6 fonctionne à partir du n 0 = 37

Remarque : on ne demande pas d’optimisation (le plus petit c ou n 0 qui
fonctionne)
juste il faut donner des valeurs qui fonctionnent (c = 10 et n 0 = 8 est donc aussi
acceptable)
19
Prouvons que la fonction f 2 (n) = 6n 2 + 2n − 8 est en O(n 2 ) :
20
Prouvons que la fonction f 2 (n) = 6n 2 + 2n − 8 est en O(n 2 ) :

but : trouver un seuil n 0 ∈ N à partir duquel : |6n2 + 2n 0 − 8| <= c|n 2 |
0 0
cherchons d’abord la constante c ; c = 6 ne peut pas marcher, essayons donc

c=7
on doit alors trouver un seuil n 0 ∈ N à partir du quel
:|6n2 + 2n − 8| <= 7|n 2 | ∀n >= n 0 ;
c = 7 et n 0 = 1
20
Règles de calcul
On calcule le temps d’exécution, mais on effectue les simplifications suivantes :

on oublie les constantes multiplicatives (elles valent 1)
on annule les constantes additives
on ne retient que les termes dominants
Exemple (simplifications) Soit g(n) = 4n 3 − 5n 2 + 2n + 3 opérations
on remplace les constantes multiplicatives par 1 : 1n3 − 1n2 + 1n + 3
on annule les constantes additives : n3 − n2 + n + 0
on garde le terme de plus haut degré : n 3 + 0
on a donc g(n) = O(n3).

Justification des simplifications
Les processeurs actuels effectuent plusieurs milliards d’opérations à la

seconde
une affectation requière 2 ou 4 unités de temps ne change donc pas grand-chose
d’où le remplacement des constantes par des 1 pour les multiplications
22

seconde
un nombre constant d’instructions est donc aussi négligeable par rapport à la

croissance de la taille des données
d’où l’annulation des constantes additives
22

seconde
un nombre constant d’instructions est donc aussi négligeable par rapport à la

croissance de la taille des données
d’où l’annulation des constantes additives
pour de grandes valeurs de n, le terme de plus haut degré l’emportera

d’où l’annulation des termes inférieurs
22
combinaison de complexité
Les instructions de base prennent un temps constant, noté O(1)

On additionne les complexités d’opérations en séquence :
O ( f 1(n)) + O ( f 2(n)) = O ( f 1(n) + f 2(n))
Même chose pour les branchements conditionnels :

combinaison de complexité
Dans les boucles, on multiplie la complexité du corps de la boucle par le nombre

d’itérations ;
La complexité d’une boucle while se calcule comme suit :

Etapes de Calcul de la complexité
Pour calculer la complexité d’un algorithme :
on calcule la complexité de chaque partie de l’algorithme

on combine ces complexités conformément aux règles qu’on vient de voir
on simplifie le résultat grâce aux règles de simplifications qu’on a vues ;
Elimination des constantes,

conservation du (des) terme(s) dominant(s)

Complexité de la fonction Factorielle
int factorielle(n)
fact = 1; O(1)
i = 2; O(1)
while (i <= n) O(n)
fact = fact * i; O(1)
i = i + 1; O(1)
return fact O(1)
26
Complexité de la fonction Factorielle
int factorielle(n)
fact = 1; O(1)
i = 2; O(1)
while (i <= n) O(n)
fact = fact * i; O(1)
i = i + 1; O(1)
return fact O(1)
Complexité de la fonction = O(1) + O(n) * O(1) + O(1) = O(n)
26
Classes de Complexité
On peut ranger les fonctions équivalentes dans la même classe

Deux algorithmes appartenant à la meme classe sont considérés de meme
complexité
Les classes de complexité les plus fréquentes (par ordre croissant en termes de
O(.))
Complexité Classe
O(1) constant
O(logn) logarithmique
O(n) linéaire
O(nlogn) sous-quadratique
O(n 2 ) quadratique
O(n 3 ) cubique
O(2 n ) exponentiel
O(n!) factorielle

Problème facile et problème difficile
Pour comparer deux algorithmes, il faut être capable de situer leur complexité
Une première distinction doit être faite entre les deux classes suivantes :
les algorithmes dits polynomiaux, dont la complexité est en O(n k )
pour un certain k
les algorithmes dits exponentiels, dont la complexité ne peut pas
être majorée par une fonction polynomiale
Classification des problèmes

un problème de complexité polynomiale est considéré "facile"
sinon (complexité non-polynomiale ou inconnue) il est considéré "difficile"

Classification des problèmes: P et NP
La classe P: est l’ensemble des problèmes qu’on peut résoudre avec un

algorithme de complexité polynomiale ;
La classe NP est l’ensemble des problèmes non polynomiaux, mais dont on peut
vérifier une solution avec un algorithme de complexité polynomiale
La question qui reste non encore résolue: P = NP ou bien P ƒ= NP
Un algorithme est dit efficace si sa complexité est au plus de l’ordre

Polynomiale.

Intérêt de la classification des problèmes
Démonstration et simplification de la résolution du problème

On peut parfois montrer que deux problèmes données
sont équivalents
ou que l’on peut résoudre l’un à l’aide de l’autre
30
Démonstration et simplification de la résolution du problème

On peut parfois montrer que deux problèmes données
sont équivalents
ou que l’on peut résoudre l’un à l’aide de l’autre
Exemple
si on peut résoudre le problème P 1 en résolvant le problème P 2, alors on a
directement un algorithme pour P 1 grâce à P 2
on a donc complexité(P 1) <= complexité(P 2)
on ne peut donc pas résoudre P 2 plus vite que P 1
30
Etude de la complexité et de l’existance d’une solution
Exemple de l’employé et de son directeur qui lui a donné un problème difficile

Réponse 1: Je n’arrive pas à trouver d’algorithme efficace, je dois être trop nul
31
Etude de la complexité et de l’existance d’une solution
Exemple de l’employé et de son directeur qui lui a donné un problème difficile

Réponse 1: Je n’arrive pas à trouver d’algorithme efficace, je dois être trop nul
Réponse 2: Je n’arrive pas à trouver d’algorithme efficace, car il n’en existe pas!!
suite reponse 2: et d’ailleurs, tous les génies n’y arriveront pas non plus.
31
Exemple de Problèmes
Rechercher le plus petit( ou plus grand) éléement dans un ensemble de données

Trier un ensemble de données
Rechercher les occurrences d’une sous chaine dans un texte.
Calculer l’itinéraire le plus court entre deux sommets d’un graphe
32
Rechercher le plus petit( ou plus grand) éléement dans un ensemble de données

Trier un ensemble de données
Rechercher les occurrences d’une sous chaine dans un texte.
Calculer l’itinéraire le plus court entre deux sommets d’un graphe
Ces problèmes sont Faciles (classe P)
32
Problème: subset sum

Données : un ensemble S de n entiers ;
Question : existe-t-il un sous-ensemble S ′ ⊂ S dont la somme des éléments est
nulle ?
Exemple : S = {−7, −3, −2, 5, 8} ; S ′ = {−3, −2, 5} est une solution
33

nulle ?
Problème: partition
Donnèes : un ensemble S de nombres (répétitions autorisées) ;
QΣuestion : Σpeut-on séparer S en deux sous-ensembles A et B tels que
a∈A a = b∈B b
Si S = {3; 1; 2; 2; 1} alors A = {3; 1} et B = {2; 2} est une solution
33

nulle ?
Problème: partition
Donnèes : un ensemble S de nombres (répétitions autorisées) ;
QΣuestion : Σpeut-on séparer S en deux sous-ensembles A et B tels que
a∈A a = b∈B b
Si S = {3; 1; 2; 2; 1} alors A = {3; 1} et B = {2; 2} est une solution
Ces problèmes sont difficiles (classe NP)
33
Problème isomorphisme de graphes

Données : deux graphes G1 et G2
Question : G1 et G2 sont-ils les mêmes ? (peut-on numéroter leurs sommets de
manière à obtenir deux ensembles d’arêtes identiques ?)




36

Ce problème est de complexité inconnu

36

Cours Complexité Algorithmique

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Complexité Algorithmique

Transféré par

Droits d'auteur :

Formats disponibles

Cours Complexité Algorithmique