Algorithmique Avancée et Complexité

Objectifs de l’enseignement
 L'objectif de ce module est d'apprendre aux étudiants
 - d'analyser et classer les problèmes.
 - construire la ou les solutions, évaluer les différentes solutions en terme de
calcul de complexité,
 - réduction de la complexité des problèmes.
Connaissances préalables
 - Algorithmique, théorie des langages, théorie des graphes
 - Un langage de programmation Python
 Contenu de la matière

- Classes de problèmes : P, NP, NP-complet

- Calcul de complexité
- Paradigme "diviser pour régner« (« divide and conquer »)
- Analyse de certains algorithmes :
- Algorithmes de tri
- Algorithmes pour les arbres et les graphes
- Programmation dynamique
- Problèmes NP et NP complets
 Introduction : analyse des algorithmes
Critères d’analyse :
 Correction : il faut que l’algorithme soit correct
 Quantité de travail effectué : complexité temps
 Quantité d’espace utilisé : complexité espace
 Optimalité : peut on faire mieux ?
 Simplicité
 Commentaires et lisibilité, etc.
 Exemple : la recherche séquentielle

Input :L, n, X : L est une liste à n éléments, X est l’élément recherché

Output : j tel que L(j) = X sinon j = 0
 j=1
 while j ≤ n and L(j) ≠ X do j = j +1
 if j > n then j = 0
j est la première occurrence de X
 Analyse : recherche séquentielle

 1. Correction : évident
 2. Quantité de travail effectué : On distingue 3 cas :
A. Cas le plus favorable
B. Cas moyen
C. Cas le plus défavorable
 Paramètres de mesure de la complexité
problème Taille de l’input
 Liste, tableau  Nombre d’entrées
 Produit de 2 matrices  Les dimensions des matrices
 Graphe
 Nombres de nœuds et/ou d’arcs
 arbre
 Nombre de nœuds
 Si N est la taille de l’input on note T(n) la complexité temps

 Le cas le plus favorable est T(n) = 1

 Le cas moyen est T(n) = n/2
 Le cas le plus défavorables est T(n)= n
 On s’intéresse au cas le plus défavorable, car il donne une idée sur la
performance de l’algorithme
 Définition de la complexité dans le cas général

Soit Dn l’ensemble des inputs de taille n : toutes les configurations où l’élément

recherché peut apparaitre
Soit I dans Dn et p(I) la probabilité que l’input I apparaisse.
Soit t(I) le nombre d’opérations fondamentales effectuées sur l’input I.
La complexité moyenne est donnée par A(n)=p(I)t(I) pour I dans Dn
La complexité la plus défavorable est donnée par W(n)=max(t(I)) pour I dans Dn
 Optimalité

 Optimalité : peut on mieux faire que T(n) = n pour la recherche séquentielle ?

Evidemment non, car il faut au moins examiner tous les éléments de la liste L
pour conclure. Donc l’algorithme est optimal et T(n) = n
 L’opération fondamentale qu’on a pris est la comparaison dans ce cas.
 Recherche dichotomique(binary search)
Input : L, n, X où L est une liste triée par ordre croissant, n est le nombre d’éléments, on
note |L|=n ou en python len(L)=n et X est l’élément recherché.
Output : j tel que L(j) = X, sinon j=0

k, m=1,n // k et m sont les bornes de L

while k ≤ m do
 j=floor((k+m)/2) // plancher de (k+m)/2
 if L(j)=X then return j
 if X < L(j) then m=j-1 else k=j+1
j=0
 Analyse de binary search
Quelle est la complexité ?
On pose T(n)=quantité de travail effectué dans une liste de dimension n
D’après l’algorithme on fait une comparaison, puis on refait le même travail sur
une des deux moitiés de la liste; donc on peut écrire que :
T(n) = 1 + T(n/2)
T(1) = 1 quand n=1 on fait une seule opération, c’est la condition de sortie de la
relation de récurrence.
 Solution de la relation de récurrence
T(n)=1+T(n/2) et T(1)=1
On a T(n/2)= 1 + T(n/2*2)
Donc T(n) = 2 + T(n/2^2)=3 + T(n/2^3) et ainsi de suite jusqu’à ce
que en général T(n) = k +T(n/2^k) (cette notation signifie 2 à la
puissance k)
On s’arrête lorsque 2^k = n pour utiliser la condition de sortie qui
est T(1)=1
Donc lorsque k =logn ce qui nous donne T(n)=logn +1
On simplifie par la constante et on conclut que T(n)=logn
 Notation asymptotique

Définition  (grand O) : ordre de (order of)

On veut caractériser le comportement asymptotique des fonctions (quand n
tend vers l’infini)
 On écrit T(n) =(f(n)) si et seulement si
 c et n0 tels que n ≥ n0  T(n)  cf(n)
 On dit que T(n) est moins complexe que f(n) quand n tend vers 
T(n) = (f(n))
 Exemples

 Notation THETA
Définition  THETA
 On écrit T(n) =(f(n)) si et seulement si  c1,c2 et n0 tels que :
n ≥ n0  c1f(n)  T(n)  c2f(n)
 On dit que T(n) est aussi complexe que f(n)
 Exemple 4n3 + 2n2+5n + 7 =(n3) car on peut facilement trouver les constantes
c1, c2 et n0
EXERCICE Montrez que 3n2 + 6nlogn = (n2)
 Notation  Grand Omega

Définition  GRAND OMEGA

 On dit que T(n) = (f(n)) si et seulement si (SSI)  c et n0 tels que n ≥ n0
 T(n) ≥ cf(n)
 f(n) est une limite inferieure pour T(n)
 Exemple 3n2 + 4nlogn = (n2) ; n7 =(n6)
 On montre facilement que T(n) =(f(n)) SSI T(n) =(f(n)) et T(n) =
(f(n))
Types de complexité
 Classes de complexité
Notation Type de complexité N=100 avec 108 ops/sec
(1) Constante Temps constant
(logn) Logarithmique 10-7 secondes
(n) Linéaire 10-6 secondes
(nlogn) Quasi linéaire 10-5 secondes
(n2) Quadratique 10-4 secondes
(n3) Cubique 10-2 secondes
(np) Exponentielle 11 jours si p=7
(2n) Exponentielle 1014 années
(n!) Factorielle 10142 années
 Temps de calcul pour des données de taille 1 million
Complexité/flops logn n n2 2n
106 0.013 ms 1s 278 heures 10000 ans
109 0.013 s 1 ms 15 minutes 10 ans
1012 0.013 ns 1 s 1 seconde 7 jours
 Références
1. « Computational complexity : A Modern approach », Sanjeev Arora and
Boaz Barak,2006
2. « Complexité et Algorithmique Avancée », Ivan Lavallée 2008
3. « The Algorithm design manual »,Steven S.Skiena, spinger 2008
 Questions ?
Les étudiants délégués sont priés de m’envoyer:
Nom, groupe, email
Consulter ma page professionnelle pour d’autres documents