Cours Complexité Algo (3LFIAG 2020-2021) DrMounaJouini

Cours
Complexité Algorithmique
Dr. Mouna Jouini
Mail: jouini.mouna@yahoo.fr
1
A.U. 2020-2021
Plan du cours
 Chap-1: Eléments de base de la complexité
algorithmique
 Chap-2: Complexité & optimalité
 Chap-3: Complexité des classes
2
Objectifs du cours
 Maîtriser la démarche «diviser pour régner»
 Savoir estimer la complexité d’un algorithme itératif

ou récursif pouvant conduire à des récurrences
linéaires d’ordre 1, d’ordre 2 et des récurrences de
type « diviser régner »
 Connaître les différents algorithmes et estimer leur

complexité
3
Chapitre 1 –Eléments de base de
la complexité
algorithméque
4
Introduction
 Un algorithme = une suite ordonnée d'instruction
écrites pour la résolution d'un problème donné.
 Algorithme = une suite d’actions que devra effectuer

un automate pour arriver à partir d’un état initial, en
un temps fini, à un résultat
 Une structure de données indique la manière

d'organisation des données dans la mémoire.
5
Introduction
 Le choix d'une structure de données adéquate
dépend généralement du problème à résoudre.
 Deux types de structures de données :

◼ Statiques: Les données peuvent être manipulées
dans la mémoire dans un espace statique alloué dès
le début de résolution du problème. Ex : les tableaux
◼ Dynamiques: On peut allouer de la mémoire pour y
stocker des données au fur et à mesure des besoins
de la résolution du problème. Ex: liste chainée, pile,
file, …
6
Introduction
Qu’est-ce qu’un problème?
 Commençons par donner quelques exemples de
problèmes :
 déterminer si un nombre naturel n est pair ou
impair;
 calculer le PGCD de deux nombres naturels m
et n;
 étant donné un graph G et deux sommets m et
n de ce graphe, déterminer s’il existe un chemin
menant de m à n dans ce graphe;
7
Introduction
Problèmes de décision?
 Un problème est dit de décision si la réponse aux
instances du problème est soit oui soit non.
Exemples :
 Déterminer si oui ou non un nombre entier n est pair
est un problème de décision;
 Par contre déterminer la longueur minimale du circuit

qui passe par tous les sommets d’un graphe n’est pas un
problème de décision, mais un problème
d’optimisation. 8
Caractéristiques d’un algorithme
 Simplicité et intelligibilité de l’algorithme
 Efficacité de l’algorithme
◼ Temps d’exécution
◼ Quantité d’espace disque occupée par les variables
◼ Quantité de trafic généré sur un réseau
◼ Quantité de données déplacées sur le disque
 Temps d’exécution versus place mémoire

occupée
9
Caractéristiques d’un algorithme
 Pour résoudre un problème donné, on veut un

algorithme
✓ correct Trouver une solution exacte ou

approchée
✓ efficace Analyser la complexité d’un

algorithme
10
Résolution d’un problème
 Pour résoudre un problème:

 Connaitre les notions de calculabilité et de
décidabilité.
 Le problème est il classique (tri, recherche dans
des graphes, programmation linéaire,…).
 Appliquer des schémas d’algorithme (diviser
pour régner, programmation dynamique,…).
11
Décidabilité et indécidabilité (1)
 Une propriété mathématique est dite décidable s'il
existe un procédé mécanique qui détermine, au bout
d'un temps fini, si elle est vraie ou fausse dans
n'importe quel contexte possible.
 L'indécidabilité c'est l'impossibilité absolue et
définitivement démontrée de résoudre par un procédé
général de calcul un problème donné.
 Dire que le problème est indécidable est plus fort que
dire que l'on ne sait pas résoudre le problème, ce qui
marquerait simplement notre ignorance.
12
 Notons que la notion de décidabilité doit être
rapprochée de celle de calculabilité.
 En effet, à toute propriété mathématique, il est toujours

possible d'associer une fonction numérique (et récip)
 En effet: une propriété mathématique P(a) est une
fonction vers un ensemble à deux valeurs, {vrai, faux}
ou, ce qui est équivalent {0, 1}. De façon symétrique, à
toute fonction y = f(x), on peut associer une propriété
P(x, y) vraie si y = f(x) et fausse sinon.
13
 En conséquence, le problème de la décision, càd la

recherche d'une procédure qui indique dans chaque
contexte, et au bout d'un temps fini, si une propriété
est vraie ou fausse, est équivalent à la construction
d'un algorithme qui calcule pour chaque fonction f et
pour chaque argument x de f, la valeur y telle que y =
f(x).
 Autrement dit, le problème de la décision est

équivalent au problème du calcul.
14
Exemple (1)
Problème A
 Soient m et n deux entiers donnés > 1. m est-il un

multiple de n ?
On sait qu'il est vrai que: 12 est un multiple de 2
et qu'il est faux que : 16 est un multiple de 5.
On sait même bien plus que cela, on sait comment s'y
prendre pour déterminer pour tout n et tout m quand il est
vrai que "m est un multiple de n» et quand il est faux que :
"m est un multiple de n« .
15
Exemple (2)
Problème A
 Il suffit en effet de :
 faire la division de m par n,
 regarder le reste obtenu, r,
 si r = 0 alors il est VRAI que "m est un multiple de n’’
 sinon il est FAUX que "n est un multiple de m"
16
Exemple (3)
Problème A
 C'est un procédé absolument sûr, qui fonctionne en un
temps fini pour tous les jeux de données possibles et
conduit toujours à la bonne réponse.
il montre que le problème A est décidable.
17
Exemple (4)
Problème B
Un problème indécidable de géométrie élémentaire.
 Soient F1 F2 ... Fn une liste de formes polygonales.
 Peut-on paver le plan, sans recouvrement ni espace vide
avec des exemplaires de F1 F2... Fn ?
 Il a été démontré que ce problème est indécidable, il
n'existe aucun algorithme permettant par un calcul fini à
partir des données (la liste des formes géométriques)
d'établir si OUI ou NON il est possible de paver le plan
avec des exemplaires des formes géométriques
considérées. 18
Complexité
 Maintenant que l’on sait ce qui peut être calculé il y a une
autre limite: l’espace et le temps.
 Parmi les problèmes que l’on peut résoudre, il y a en a
certains qui sont plus faciles que d’autres:
 Ex1: pour trier une liste, il y a des algorithmes en O(n
log n). C’est considéré comme un problème facile
(surtout avec les machines d’aujourd’hui).
 Ex2: Pour résoudre le problème du voyageur de
commerce, on ne connait pas d’algorithmes non
exponentiels : il y a environ n! chemins possibles. Si n
= 15 alors 15! = 1307674368000 Donc il est très difficile.
19
Quelques paradigmes pour un algorithme
efficace
 Un paradigme est une méthode générique qui
s'applique dans plusieurs situations algorithmiques.
 L'induction: Ce paradigme donne lieu à des
processus itératifs.
 Diviser pour régner: tous les algorithmes récursifs.
 Trouver un ordre "optimal" sur les opérations à
effectuer
Exemples :
•les parcours en profondeur dans les graphes,
•les utilisations des ordres lexicographiques.
20
Quelques paradigmes pour un algorithme
efficace
 Utiliser une structure de données ad hoc: pour
résoudre efficacement les opérations de base de
l'algorithme.
 Exemples : arborescences binaires ordonnées de
recherche, arborescences bicolorées,…
 Utiliser un procédé stochastique (à base de tirages

aléatoires). Les algorithmes randomisés ou
probabilistes sont souvent très simples à mettre en
oeuvre et donnent le bon résultat.
21
Exemple : Calcul de la valeur d’un
polynôme
 Soit P(X) un polynôme de degré n P(X) = anXn +
an-1Xn-1 + ... + a1X + a0
 Où,
◼ n : entier naturel
◼ an, an-1, ..., a1, a0 : les coefficients du polynôme
 1ère variante :
début
P=0 Coût de l’algorithme :
Pour i de 0 à n faire - (n+1) additions
P= P+ ai*Xi - (n+1) multiplications
finpour - (n+1) puissances
fin 22
polynôme
 2ème variante :
debut
Inter=1 P =0
Coût de l’algorithme :
Pour i de 0 à N faire - (n+1) additions
P= P+ Inter *ai - 2(n+1) multiplications
Inter = Inter * X
finpour
Fin
23
polynôme
 3ème variante : Schéma de Horner
P(x) = (….(((anx+an-1)x+an-2)x+an-3)…..)x+a0
début
P = an
Pour i de n-1 à 0 (pas = –1) faire
P = P*X + ai Coût de l’algorithme:
Fin pour Fin - n additions
- n multiplications
➔ Nécessité d’estimer le coût d’un
algorithme avant de l’écrire et l’implémenter
24
Chapitre 2 – Complexité et
optimalité
25
Plan
Complexité temporelle et spatiale

Calcul du coût d’un algorithme
Approximation des complexités
26
Introduction
 La complexité algorithmique permet de mesurer les
performances d'un algorithme afin de le comparer avec
d'autres algorithmes résolvant le même problème.
 L’idée est de quantifier les deux grandeurs physiques

(temps d’exécution, place mémoire) dans le but de
comparer différents algorithmes qui résolvent le même
problème, indépendamment:
 des détails d’implémentation.
 de la machine,
 du langage de programmation, compilateur 27
Introduction
 La complexité algorithmique cherche à analyser le
comportement des algorithmes (son temps
d'exécution et/ou la place mémoire occupée) en
fonction de la taille des données d'entrée.
 La complexité algorithmique permet de dire si :

 Un algorithme A est meilleur qu’un algorithme B.
 Un algorithme A est optimal.
 Un algorithme ne doit pas être utilisé.
28
Définition
◼ Critères d’évaluation d’un programme
◼ Est-ce que le programme satisfait les spécifications de
la tâche ?
◼ Est-ce qu’il fonctionne correctement ?
◼ Est-il bien documenté ?
 (commentaires, guide d’utilisation)

◼ Est-ce que le code est lisible ?
◼ …
Ces critères sont associés au développement 29

Définition
◼ Évaluation de performances d’un programme
◼ Est-ce que le programme utilise efficacement la
mémoire ?
◼ Est-ce que son temps d’exécution est acceptable?
Complexité des algorithmes

◼ Estimations de temps et d’espace
◼ Indépendants de la machine
30
Complexité temporelle et
spatiale
31
Complexité temporelle (1)
◼ La complexité temporelle d’un algorithme est la quantité
de temps nécessaire à son exécution complète
◼ Le temps d’exécution est proportionnel au nombre
d’opérations fondamentales effectuées par l’algorithme
◼ Opérations fondamentales : lecture, écriture, addition,
soustraction, comparaison, multiplication,…
◼ On supposera que chaque opération
fondamentale de l’algorithme prend un temps
unitaire (1)
32
x=0 ; (1 op affectation)
y=0 ; (1 op affectation)
x=x+1 ; (2 ops: 1 addition + 1 affectation)
z=x+y; (2 ops: 1 addition + 1 affection)
y=z; (1 op affectation)
Exemple
Dans cecas on va considérer que les opérations d’addition et
affectation sont fondamentales.
Donc comme opérations fondamentales, on a 7 opérations.
33
Exemple
int recherche (float tab[], int n, float elem)

{
int i, trouve = 0 ; i=0 ;
while ((i <n) && (! trouve))
{
if (tab[i] ==elem)
trouve = 1;
i=i+1;
}
if (i>=n) i=-1; return i; }
Comme opérations fondamentales, nous n’allons prendre que la

comparaison de elem avec les éléments du tableau. 34
Complexité spatiale
◼ La complexité spatiale d’un algorithme est la quantité
de mémoire nécessaire à son exécution complète.
Même type de calcul, mais plutôt en terme de cases

mémoires (octets) au lieu du nombre d’opérations
fondamentales.
35
Calcul du coût d’un
algorithme
36
Temps d’exécution (1)
▪ Le temps d’exécution d’un algorithme est en général
exprimé en fonction des données sur lesquelles il opère.
▪T(n) est le temps d’exécution exprimé en fonction des
données de taille n. C’est également le nombre
d’opérations élémentaires.
▪ Il faut donc définir une mesure de taille sur les données.
▪ Le temps d'exécution d'un programme dépend :
▪ du nombre de données,
✓de la taille du code,
✓du type d'ordinateur utilisé (processeur, mémoire),
37
Règles générales
oLe temps d’exécution d’une affectation ou d’un test est

considéré comme constant c (généralement 1).
oLe temps d’une séquence d’instructions est la somme des
temps d’exécution qui le composent.
oLe temps d’un branchement conditionnel est égal au
temps d’exécution du test plus le maximum des deux temps
d’exécution correspondant aux deux alternatives.
oLe temps d’une boucle est égal à la somme du coût du test
plus du corps de la boucle. 38
Exemple
o T (n) = c1 + c1 + n (c2 + c3 + c4 + c5 + c1)
5
= 2c1 + n ci
i=1
✓c1 : affectation
✓c2 : incrémentation
✓c3 : test
✓c4 : addition
✓c5 : multiplication
Ces constantes peuvent prendre la valeur 1.
Rq: Le nombre de test est plus exactement n+1. 39
Différents coûts d’un algorithme (1)
oOn ne peut généralement pas calculer de manière

exacte le coût d’un algorithme (types de complexité).
On considère :
✓Le meilleur des cas
✓Le pire des cas (on vas s’interesser)
✓Le cas moyen

40
Evaluation de la complexité (1)
◼ Il n'existe pas Schéma décisionnel de mode d'emploi

qui donne à chaque fois l'estimation de la performance
d'un algorithme.
◼ Mais on peut toujours se baser sur le fait que les

algorithmes sont conçus de manière structurée.
41
Evaluation de la complexité (2)
◼ Les algorithmes structurés combinent les

instructions de contrôles de 4 manières
différentes:
◼ Sequence d'instruction
◼ Schema decisionnel
◼ Boucle ou iteration
◼ Appel a un sous programme
◼ P(I) note le nombre d’opérations fondamentales

effectuées par l’instruction I (séquence d’instructions,
schéma décisionnel, etc.) 42
Instruction simple
◼ Pour les instructions simples qui ne font pas appel à
un sous programme comme l'affectation et les
opérations de lecture/écriture l'instruction prend un
temps d'exécution fixe (constant) dénoté O(1): de
l’ordre de 1
◼ Une séquence d'instructions prend la "somme" des
temps d'exécution de chaque instruction dans la
séquence.
◼ Si chaque instruction est en O(1) alors la somme l'est
aussi. 43
Schémas de choix
◼ Pour les schémas de choix ou schémas

décisionnels, on retiendra la complexité
maximale des différentes alternatives.
P(if(cond) I1 else I2) ≤

P(cond)+max(P(I1), P(I2))
44
Schémas itératifs (1)
◼ Hypothèse: le traitement à l’intérieur de la boucle est
O(1)
◼ Si le nombre d’itérations est constant alors la
complexité est O(1)
◼ Exemple: Parcours d'un intervalle constant 1..5 alors la
complexité est O(1). Sinon si le nombre d’itérations est
fixée à N alors la complexité est O(N)
◼ Exemple:
Pour i = 1..N Faire
opérations en O(1) N opérations
45
FinFaire
◼ 2 boucles imbriquées (chacune à N itérations) avec des
instructions en O(1) : Complexité = O(N2)
◼ 3 boucles imbriquées (chacune à N itérations) avec des
instructions en O(1) : Complexité = O(N3)
◼ …
◼ M boucles imbriquées (chacune à N itérations) avec
des instructions en O(1) : Complexité = O(NM)
46
Exemple:
Pour i = 1..N Faire
Pour j=1..N faire
opérations en O(1)
FinFaire
… FinFaire
N opérations qui vont se faire N fois donc N*N=N2
47
Boucles multiplicatives (1)
◼ Les boucles multiplicatives sont des boucles contrôlées
par une variable qui, à chaque exécution de la boucle, est
divisée ou multipliée par une constante.
◼ Exemple:
var = 1
Tantque var <= N faire
…….
qqchose en O(1)
…….
var = 2*var
FinFaire
Ici, la constante = 2 48
◼ Puisque var est initialisé à 1, après k itérations la variable var
sera égale à 2k (car à la sortie de la 1ère itération var=2=21 puis à
la sortie de la 2ème itération var=4=22, à la sortie de la 3eme
itération var=8=23 etc.)
◼ Pour trouver la complexité temporelle il faut trouver k
◼ Le nombre d'itérations k peut être trouvé en appliquant la
fonction logarithme des deux côtés de l'égalité
var = 2k
Log2(var) = log2 (2k) N
◼ Puisque l'itération se
= k log2(2) termine quand var
= k Donc >= N, la complexité
de l'algorithme est en
k = log2(var) O(log (N)) 49
◼ En général, si l'on suppose que la variable de contrôle
var est multipliée par une constante Facteur, alors on
peut voir qu'après k itérations, var = Facteurk
◼ Dans ce cas :
var = Facteurk
logFacteur(var) = logFacteur (Facteurk)
= k logFacteur (Facteur)
= k Donc k
= logFacteur (var)
Pour var = N, k= logFacteur (N) 50
Travail à faire
◼ Donner la complexité de l’algorithme suivant
var = N
Tantque var > 1 Faire
……..
qqchose en O(1)
……..
var = var/2
FinFaire
51
Travail à faire (sol)
◼ Puisque var est initialisé à N, après k itérations la
variable var sera égale à N/2K
◼ Le nombre K peut être calculé comme suit:
var = N/2K
log2(var) = log2 (N/2K)
= log2(N)-log2(2K)
= log2(N)-K*log2(2)
= log2(N)-K
Donc k = log2(N) - log2(var)

◼ Puisque l'itération se termine quand var  1 log(var) est une
constante (déjà égale à zéro) donc symplifiée
52
Recap
◼ Cela revient au même que d'initialiser la variable var de parcours à une
grande valeur et de la diviser par une constante (ici 2) pour la faire
converger vers une petite valeur que d'initialiser la variable var de
parcours à une petite valeur et de la multiplier par une constante (ici 2)
pour la faire converger vers une grande valeur.
Compteur avec un
Compteur avec
pas de 1
un pas de 2
◼ En général la complexité algorithmique est en

O(logBase du multiplicateur ou du diviseur (N))
53
Complexité en O(N log(N)) (1)
Exemple 1: Boucles imbriquées
Pour i = 1..N Faire
var =1
Tantque var <= N Faire
……
qqchose en O(1)
……
var = Const*Var FinFaire
FinFaire
Complexité en O(N logConst(N)) 54

Complexité en O(N log(N)) (2)
◼ Exemple 2: Boucles imbriquées
Pour i = 1..N Faire
var = N
Tantque var > 1 Faire
……
qqchose en O(1)
……
var = var/const FinFaire
FinFaire
Complexité en O(N logConst(N)) 55

Règles
◼ c*f(n) = O(f(n)) pour tout facteur constant c
◼ f(n) + c = O(f(n)) pour tout facteur constant c
◼ f(n) + g(n) = O(max(f(n), g(n)))
◼ f(n) x g(n) = O(f(n) x g(n))
◼ Si f(n) est un polynôme de degré m:
f(n)=a0+a1n+a2n2+…+amnm
alors f(n) est de l’ordre du degré le plus
grand: O(nm)
◼ nm = O(cm) pour tout m > 0 et c > 1
◼ log nm = O(log n) pour tout m > 0 56
Exemple 1 (1)
◼ Pour les fonctions de tri la mesure de complexité
correspond au nombre de comparaisons d’élément
exprimé en fonction du nombre d’élément à trier
Algo Tri par sélection
◼ Exemple:
-- Précond: tab contient n valeurs, n > 1
-- Postcond: trie par sélection en ordre croissant des n
valeurs de tab
pourtouti de 1 à n-1 faire
min  i
pourtoutj de i+1 à n faire
si tab[j] < tab[min] alors min  j
finsi finpour
échanger tab[i] et tab[min]
finpour 57
Rappel
◼ La somme des n premiers termes d’une suite
géométrique de premier terme u0 et de raison q ≠1 est:
▪La somme des n+1 premiers termes d’une suite

arithmétique de premier terme u0 et de raison r est:
◼ Le nième terme d’une suite arithmétique de premier

terme u0 et de raison r est: 58
Exemple 1 (2) – solution
◼ La complexité spatiale = O(n):
◼ si on multiple par 100 le nombre d’éléments à trier le
programme utilise un tableau 100 fois plus grand

◼ La complexité temporelle = O(n2):
◼ À chaque étape i du tri la comparaison est exécutée
par la boucle la plus interne n-i fois.

◼ Il y a n-1 étapes (dans la boucle externe)
◼ Étape 1: n-1 comparaisons
◼ Etape 2: n-2 comparaisons
◼ Etape n-1: 1 comparaison 59

◼ C’est une suite arithmétique dont le premier terme est
1, le dernier (n-1) et la raison est de 1. Donc le nombre
de comparaisons exécuté est :
(n -1)(1+ n −1) n −n 2
 uk = 2
=
2
k =1
60
◼ La fonction (n2-n)/2 est un polynôme de degré 2 donc

la complexité temporelle est de l’ordre de O(n2)
◼ Cela signifie que si on multiplie par 100 le nombre

d’éléments à trier alors le temps d’exécution sera
multiplié par 10000
61
Signification
Pourquoi ½(n2-n) est approximé par 0(n2 ) ?
◼ Soit deux fonctions positives f et g, on dit que f(n) est en
O(g(n)) (de l’ordre de g(n)) s’il existe deux constantes
positives c et n0 t.q n  n0, f(n) ≤ c g(n)
◼ Dans notre exemple : f(n)= ½(n2-n) et g(n)= n2 car pour
c=1/2 et n0 = 0 on a  n  0, ½(n2-n) ≤ ½ n2
40
½ n2
30
½ (n2-n)
25
20
15
10
5
0 62
0
Exemple 2 (1)
◼ factorielle d’un entier n
◼ version itérative (Rq: Opération fondamentale :
multiplication)
static int factIter(int n)
{ int r=1;
for(int i=1; i<=n; i++) r=r*i;
}
◼ version récursive
static int factRec(int n)
{
if(n==0) return 1;
else return n*factRec(n-1);
} 63
◼ Mesure de la complexité temporelle
◼ Version itérative
P(i) =1, il ya n itérations   P(i) = n

complexité O(n)
◼Version récursive P(0)=0, P(n)=P(n-
1)+1=n
complexité O(n)
◼ Mesure de la complexité spatiale
◼ Version itérative  complexité O(1)
◼ Version récursive  complexité O(n) 64
Résumé
1 constante (indépendante de la taille des
données)
log2 n logarithmique
n*log (n) quasi-linéaire
n linéaire
n2 quadratique
n3 cubique
nP polynomiale
cn (c  1) exponentielle
65
Illustration (1)
◼ Temps d’exécution : Exemple
◼Sur un ordinateur effectuant 1000 000 opérations par
seconde (1 Mhz)
◼s: micro-secondes, ms: milli-secondes, s :secondes,
mn:minutes, h: heure, j: jour, a : année,

Complexité log(n) n n*log(n) n2
Taille
n=102 6.6s 0.1ms 0.6 ms 10 ms
n=103 9.9s 1 ms 9.9 ms 1s
n=104 13.3s 10 ms 0.1 s 100 s
n=105 16.6s 0.1 s 1.6 s 2.7 h
n=106 19.9s 1s 19.9s 11.5 j
66
Illustration (2)
Complexité n3 2n
Taille
n=102 1s 4x106 a
n=103 16.6 mn >10100 a
n=104 11.5 j >10100 a
n=105 31.7 a >10100 a
n=106 31.7x103 a >10100 a
67
Travail à faire (1)
◼ 1. Calculer la complexité temporelle de la fonction de
recherche d’un élément dans un tableau
Fonction Appartient (donnée T: tableau d’entiers, donnée N, x:
entier) retourne booléen
début
variable i : entier i  1;
tantque ( i ≤ N et T[i] ≠ x) faire
i i+1
fin tantque
si (i>N) retourner faux
sinon retourner vrai
finsi fin
◼ Opérations significatives : comparaisons

68
Travail à faire- Recherche (sol)
◼ Complexité :
◼ Il y a au plus N itérations (N est la taille des

données)
◼ La complexité est de N au pire des cas: O(N)
69
Travail à faire (2)
◼ 2. Complexité temporelle de la recherche

dichotomique
◼ Recherche d’un élément dans un tableau de n
éléments triés
◼ Principe: diviser l’intervalle en 2 et tester sur
l’élément du milieu si ok arrêt sinon recherche à
droite ou à gauche
70
Complexité en fonction de deux
paramètres
Déterminer la complexité des algorithmes
suivants (par rapport au nombre d'itérations
effectuées), où m et n sont deux entiers positifs.
Algorithme A
i 1; j 1
Tant que (i m) et j  n) faire
i i+1; j j+1;
Fin Tant que
71
paramètres
Algorithme A
i 1; j 1
Tant que (i m) et j  n) faire
i i+1; j j+1;
Fin Tant que
Réponse L'algorithme A est en O (min(m,n)) 72

paramètres
Algorithme B
i 1; j 1
Tant que (i m) ou (j  n) faire
i i+1; j j+1;
Fin Tant que
73
paramètres
Algorithme B
i 1; j 1
Tant que (i m) ou j  n) faire
i i+1; j j+1;
Fin Tant que
Réponse L'algorithme B est en O (max(m,n)) 74

paramètres
Déterminer la complexité des algorithmes suivants
(par rapport au nombre d'itérations effectuées), où m
et n sont deux entiers positifs.
Algorithme B
i 1; j 1
Tant que (j  n) faire
si i m alors
i i+1;
sinon
j j+1;
Fin si
Fin Tant que 75
paramètres
Déterminer la complexité des algorithmes suivants (par
rapport au nombre d'itérations effectuées), où m et n
sont deux entiers positifs.
Algorithme C
i 1; j 1
si i m alors
i i+1;
sinon
j j+1;
Fin si
Fin Tant que
Réponse L'algorithme C est en O (m+n) 76
paramètres
Algorithme B
i 1; j 1
si i m alors
i i+1;
sinon
j j+1; i  1;
Fin si
Fin Tant que 77
paramètres
Algorithme B
i 1; j 1
si i m alors
i i+1;
sinon
j j+1; i  1;
Fin si
Fin Tant que
Réponse L'algorithme A est en O (mn)
78
Approximation des
complexités: Complexité
Asymptotique
79
Approximation des complexités (1)
▪Parfois, on ne calcule pas la complexité exacte mais on

essaie de trouver :
✓ son ordre de grandeur asymptotique.
✓ ou bien essayer de la borner.
▪Exemple
▪Si on a n2 + 4n - 7 opérations, on retiendra l’ordre de

grandeur qui est n2.
▪Si on a n3 + 2n2 + 5 opérations, on retiendra l’ordre de
grandeur qui est n3. 80
▪Dans les approximations, il n’est pas utile de tenir

compte des constantes additives.
▪Exemple:
Il n’est pas important de savoir si un algorithme fait
▪n opérations, ou
▪n+1 opérations, ou
▪même n+10 opérations
quand n grand.
81
▪Même raisonnement pour les constantes
multiplicatives, mais il faut être plus prudent au moment
de l’approximation.
▪Exemple:
▪Un algorithme A1 a une complexité (Min, Max, ou Moy)
égale à n2 et un algorithme A2 de complexité 2n.
▪A2 est meilleur que A1 que si n>2.
▪3n2 – 25n = n (3n - 25) est toujours > 0 pour n>2.
▪Si A1 a pour complexité 3n2 et A2 a 25n,
▪A2 est meilleur que A1 pour tous les n>2.
▪n2 – 2n = n (n - 2) est toujours > 0 pour n>2. 82
▪Peu importe les constantes multiplicatives, si A1 a

pour complexité k1*n2 et A2 a pour complexité k2*n.
A2 est toujours meilleur que A1 à partir d’une

certaine valeur de n, car la fonction n2 croît
beaucoup plus vite que n: lim(n tend vers l’infini)n/n2 =0
On dit alors que l’ordre de grandeur asymptotique de

n2 est strictement plus grand que celui de n.
83
Ordre de grandeur asymptotique et
notation de Landau
▪On veut comparer les algorithmes A1 et A2.

▪Si l’ordre de grandeur asymptotique de A1 est strictement
plus grand que celui de A2.
A2 est meilleur que A1 pour n grand.
▪Si A 1 et A2 ont le même ordre de grandeur asymptotique.
Faire une analyse plus fine pour comparer A1 et A2.
Pour comparer les ordres de grandeur asymptotique,
on utilise la notation ≪Landau≫ en
mathématiques permettant de caractériser le
comportement asymptotique (i.e. quand n → ∞). 84
Ordre de grandeur asymptotique et
notation de Landau
▪Soient f et g deux fonctions de N dans R:
▪Lorsqu’une complexité est donnée en termes de O(g), il

serait intéressant de donner la fonction g la plus ≪serrée≫
possible.
▪Pour toutes les grandes entrées (i.e., n≥ n0), on est assuré
que l’algorithme ne prend pas plus de c*g(n) étapes.
On parle de borne supérieure asymptotique. 85
Notation de Landau
▪La notion grand O, aussi appelée symbole de Landau, est
un symbole utilisé en théorie de la complexité, en
informatique, et en mathématiques pour décrire le
comportement asymptotique des fonctions. Elle indique
avec quelle rapidité une fonction «augmente» ou
«diminue».
▪Le symbole de Landau porte le nom du mathématicien
allemand spécialisé en théorie des nombres Edmund Landau
qui a utilisé cette notation introduite primitivement par
Bachmann.
▪La lettre O est utilisée parce que la course de la
«croissance» d'une fonction est aussi appelée l'ordre. 86
Notation grand-O
Borne supérieure asymptotique
Définition
◼ O(g(n)) ={f: N →N /  k>0 et n0  0

tels que  n n0, 0  f(n)  k g(n)}
Si une fonction f(n)  O(g(n)), on dit que g(n) est une

borne supérieure asymptotique pour f(n).
◼ Par abus de notation, on écrit aussi:

f(n) = O(g(n)) 87
Notation grand-O
◼ Signification: Pour toutes les grandes entrées

(i.e., n  n0), on est assuré que l’algorithme ne
prend pas plus de cste*g(n) étapes.
 Borne supérieure.
Noter que c’est la plus petite borne Supérieure qui est

recherchée.
88
Notation grand-O
Exemple 1
Pourquoi ½(n2-n) est approximé par 0(n2 )?
◼ Dans notre exemple : F(n)= ½(n2-n) et g(n)= n2
car pour k=1/2 et n0 = 0 on a  n  0,
½(n2-n) ≤ ½ n2
40 ½ n2
½ (n2-n)
35
30
25
20
15
10
0
5 0 89
Notation grand-O
Exemple 2
Initialiser un tableau d’entiers
for (int i=0; i<n; i++) Tab[i]=0;
Il y a n itérations
Chaque itération nécessite un temps constant c, où c
est une constante (accès au tableau + une
affectation).
Le temps est donc f(n) = cn Donc f(n) = O(n) 90

Notation grand-O
Exemple 3: f(n) = c1n2 + c2n .

c1n2 + c2n  c1n2 + c2n2 <= (c1 + c2)n2
pour tout n  1.
f(n)  cn2 où c = c1 + c2 et n0 = 1.
Donc, f(n) = O(n2).
Exemple 4: f(n) = c. On écrit f(n) = O(1).
91
Exercices complexité asymptotique
Exercice 1: Démontrer que
1. n2O (10-5n3)
2. 25 n4-19n3+13n2 O (n4)
3. 2n+100  O(2n)
92
Solution exercice 1
n2O (10-5n3)
Il suffit de trouver deux entiers strictement positifs k
et n0 tels que n2  k 10-5n3  n  n0
Si l'on prend k = 105 et n0 = 1, il est évident

que n2  105 10-5n3  n  1
Donc n2O (10-5n3)

93
25 n4-19n3+13n2 O (n4)
25 n4-19n3+13n2  25 n4+19n3+13n2  25
n4+19n4+13n4 =(25+19+13) n4  n  1
Il suffit donc de choisir k= 25+19+13 = 57 et n0 = 1

2n+100  O(2n),
avec k = 2100 et n0 = 0,
n+100 100 n
2 2 2 n0
94
Exercice 2
Donner les relations d'inclusion entre les ensembles

suivants:
O(nlog(n)), O(2n), O(log(n)), O(1), O(n2), O(n3), O(n)
95
 Solution de l’exercice 2
 Il est évident que:

 O(1) O(n)  O(n2)  O(n3)
 car 1  1 n  1 n2  1 n3 n1
 On a également O(1)  O(log(n))  O(n)  O(n log(n)),

puisque 1  log(n)  n  3 et
log(n)  n n1
Et log(n)  n n 1
 n log(n)  n2 n1 96
Solution de l’exercice 2
On montre maintenant que O(n3)  O (2n)

n3  2n  log(n3)  log (2n)  3 log(n)  n log (2)
→ log(n)  n (log (2)/3)  0,23 qui est vrai à

partir d'une certaine valeur de n (par exemple n =
20) puisque log(n)  O(n)
On a donc en final:
O(1)  O(log(n))  O(n)  O(nlog(n))  O(n2)  O(n3) 
97
n
Complexité asymptotique en termes de
temps d'exécution
◼ Soit un ordinateur qui exécute 1000000 d'instructions par
seconde, on exécute un algorithme qui utilise, pour une donnée
de taille n = 60, f(n) instructions, f(n) étant l'une des fonctions,
nlog(n), 2n, log(n), 1, n2, n3, n
◼ Voici le tableau qui donne le temps d'exécution correspondant à
chacune des fonctions
F(n) Temps en secondes
log(n) 4,09 10-6
n 6 10-5
n log(n) 2,46 10-4
n2 3,60 10-3
n3 2,16 10-1
2n 1,15 1012  36 558 ans  9 ans sur un ordinateur récent
98
Exercices calcul complexité
Soit la fonction récursive F d'un paramètre entier n suivante:
Fonction F(n:entier): entier
Si n=0 alors
Retourner 2
Sinon
retourner (F(n-1)*F(n-1)) Fin si
1. Que calcule cette fonction

2. Déterminer la complexité temporelle de la fonction F
3. Comment améliorer cette complexité
99
Réponse
1. Que calcule la fonction F(0) = 2,
F(1) = 2*2 = 22 , F(2) = 22 * 22 = 24
F(3) = 24 * 24 = 28
intuitivement on peut conclure que F(n)= 2n
2. Calcul de complexité
On s'interesse au nombre m(n) de multiplications
effectuées. M(n) est solution de l'équation de
recurrence
100
Réponse
On montre par la suite que
On en déduit que l'algorithme est en O(2n) et possède donc une

complexité exponentielle
3. Comment améliorer cette complexité: Il faut éviter le
double appel récursif! La fonction F devient:
Fonction F(n:entier):entier Si n=0
alors
Retourner 2 Sinon
retourner F(n-1)**2 // puissance 2
Fin si 101
Chapitre 3 –
Complexité des classes
102
Plan
 Classes de complexité standards
 Relations d'inclusion
103
Introduction
o Pourquoi certains problèmes sont-ils plus difficiles à résoudre

que d’autres?
o On peut distinguer entre:
✓ Les problèmes pour lesquels on peut facilement trouver une
réponse.
✓ Les problèmes pour lesquels on peut facilement vérifier
qu’une réponse est correcte si celle-ci est connue.
✓ Les autres...
104
Problème de décision
▪La théorie de la complexité ne traite que des problèmes de
décision binaire, c'est-a-dire posant une question dont la
réponse soit oui ou non .
▪Cependant on étend la notion de complexité aux problèmes
d'optimisation. En effet il est facile de transformer un
probleme d'optimisation en probleme de décision.
▪Exemple: on cherche a optimiser une valeur n on traite le

probleme de décision qui consiste a comparer n a un certain
k. En traitant plusieurs valeurs de k on peut déterminer une
valeur optimale.
105
106
Algorithme pour REACH
107
Notion de réduction entre problèmes
108
Définition
Un problème Pb1 est plus simple qu’un problème Pb2

(noté Pb1≤ Pb2): s’il existe une fonction f: DPb1 ⟼DPb2
qui se calcule en temps polynomial telle que:
x ∈ YPb1 ssi f(x) ∈ YPb2

Exemple:
109
Problème 1 plus simple que Problème 2

Problème 1 se réduit polynomialement en Problème 2 110
Complexité d’un problème (1)
o Il s’agit de répondre à certaines questions:
o Quelle est la complexité minimale d’un algorithme
résolvant tel problème?
o Existe-t-il un algorithme polynômial pour résoudre un
problème donné?
o Comment peut-on dire qu’un algorithme est optimal (en
complexité)?
o Comment peut-on montrer qu’il n’existe pas d’algorithme
polynômial pour un problème?
…
111
Complexité d’un problème (2)
o Par exemple, si on dit que la complexité d’un problème est
quadratique cela veut dire:
✓ qu’il existe un algorithme quadratique qui le résout.

✓ Et que tout algorithme qui le résout sera au moins
quadratique.
112
Classe P
Classe NP
Autres classes (L, NL, EXPTIME, Co-
NP, EXPTIME)
113 113
Familles de classes de complexité (1)
o Il s’agit de classifier les problèmes selon l’ordre de
grandeur de leur complexité.
o on va se limiter aux problèmes de décision ou propriétés.
o Une propriété est une fonction à valeurs booléennes.
o Un problème de décision peut donc être vu comme un
ensemble d’instances du problème avec pour chaque
instance une réponse “oui” ou “non”.
114
Classe P
P = PTIME = c TIME(nc)
o La classe P est l’ensemble des problèmes de décision

D qui admettent un algorithme de résolution
Polynomial.
o Complexité < O(nk) avec

n= taille des données en entrée du problème D
c = constante indépendante de n.
115
Exemples de problèmes dans P
o ”Etre pair” est dans P

o ”Etre trié” pour un tableau d’entiers est dans P.
o ”Etre premier” est dans P.
o Le problème de la connexité dans un graphe: Étant donné un
graphe à s sommets, il s'agit de savoir si toutes les paires de
sommets sont reliées par un chemin.
o Rechercher un plus court chemin entre 2 sommets d’un graphe:
Djikstra
116
Classe NP
NP = c NTIME(nc)
o La classe NP des problèmes Non-déterministes Polynomiaux

réunit les problèmes de décision qui peuvent être décidés sur
une machine non déterministe en temps polynomial
o La classe NP réunit les problèmes de décision pour lesquels la
réponse oui peut être décidée par un algorithme non-
déterministe en un temps polynomial par rapport à la taille de
l'instance.
117
Exemples de problèmes dans NP
• Problème du plus court chemin dans un graphe:
Il est possible de vérifier en temps polynomial si un chemin
donné relie a et b et si sa longueur est inférieure à une valeur B.
•Problème du plus long chemin dans un graphe:
il est possible de vérifier en temps polynomial si un chemin
donné est élémentaire, s’il relie a et b et si sa longueur est
inférieure à une valeur B.
•Problème hamiltonien:
Lorsqu’un graphe G admet un cycle hamiltonien, il est possible
de vérifier en temps polynomial si un tel cycle passe une et une
seule fois par tout les sommets de G.
• Problème du voyageur de commerce , 3 SAT, 3 COL
118
Autres classes de complexité (1)
 L = LOGSPACE = SPACE(log n)
Un problème de décision qui peut être résolu par un algorithme
déterministe en espace logarithmique par rapport à la taille de
l'instance est dans L
 NL= NLOGSPACE = NSPACE(log n)

 PSPACE = c SPACE(nc)
La classe PSPACE est celle des problèmes décidables par une
machine déterministe en espace polynomial par rapport à la
taille de sa donnée. On peut aussi définir NSPACE NPSPACE
119
Merci pour votre attention
!
120

Cours Complexité Algo (3LFIAG 2020-2021) DrMounaJouini

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é Algo (3LFIAG 2020-2021) DrMounaJouini

Transféré par

Droits d'auteur :

Formats disponibles

Cours

Dr. Mouna Jouini

 Chap-2: Complexité & optimalité

 Chap-3: Complexité des classes

 Savoir estimer la complexité d’un algorithme itératif

 Connaître les différents algorithmes et estimer leur

 Algorithme = une suite d’actions que devra effectuer

 Une structure de données indique la manière

 Deux types de structures de données :

 Par contre déterminer la longueur minimale du circuit

 Temps d’exécution versus place mémoire

 Pour résoudre un problème donné, on veut un

✓ correct Trouver une solution exacte ou

✓ efficace Analyser la complexité d’un

 Pour résoudre un problème:

 En effet, à toute propriété mathématique, il est toujours

 En conséquence, le problème de la décision, càd la

 Autrement dit, le problème de la décision est

 Soient m et n deux entiers donnés > 1. m est-il un

il montre que le problème A est décidable.

 Utiliser un procédé stochastique (à base de tirages

Complexité temporelle et spatiale

 L’idée est de quantifier les deux grandeurs physiques

 La complexité algorithmique permet de dire si :

 (commentaires, guide d’utilisation)

Ces critères sont associés au développement 29

Complexité des algorithmes

int recherche (float tab[], int n, float elem)

Comme opérations fondamentales, nous n’allons prendre que la

Même type de calcul, mais plutôt en terme de cases

oLe temps d’exécution d’une affectation ou d’un test est

oOn ne peut généralement pas calculer de manière

✓Le meilleur des cas

✓Le pire des cas (on vas s’interesser)

✓Le cas moyen

◼ Il n'existe pas Schéma décisionnel de mode d'emploi

◼ Mais on peut toujours se baser sur le fait que les

◼ Les algorithmes structurés combinent les

◼ Appel a un sous programme

◼ P(I) note le nombre d’opérations fondamentales

◼ Pour les schémas de choix ou schémas

P(if(cond) I1 else I2) ≤

N opérations qui vont se faire N fois donc N*N=N2

◼ Donner la complexité de l’algorithme suivant

Donc k = log2(N) - log2(var)

◼ En général la complexité algorithmique est en

Complexité en O(N logConst(N)) 54

Complexité en O(N logConst(N)) 55

▪La somme des n+1 premiers termes d’une suite

◼ Le nième terme d’une suite arithmétique de premier

programme utilise un tableau 100 fois plus grand

par la boucle la plus interne n-i fois.

◼ Étape 1: n-1 comparaisons

◼ Etape 2: n-2 comparaisons

◼ Etape n-1: 1 comparaison 59

◼ La fonction (n2-n)/2 est un polynôme de degré 2 donc

◼ Cela signifie que si on multiplie par 100 le nombre

P(i) =1, il ya n itérations   P(i) = n

mn:minutes, h: heure, j: jour, a : année,

◼ Opérations significatives : comparaisons

◼ Il y a au plus N itérations (N est la taille des

◼ La complexité est de N au pire des cas: O(N)

◼ 2. Complexité temporelle de la recherche