No d’ordre :

o
N attribué par la bibliothèque :

Université DE CARTHAGE
École Nationale des Ingénieurs de Carthage
Département d’Informatique Appliquée

Support de Cours
ALGORITHMIQUE FONDAMENTALE
ET COMPLEXITÉ
MASTÈRE DE RECHERCHE EN INFORMATIQUE

Responsable du Module

Hazem FKAIER

Dernière mise-à-jour de ce document est effectuée le :

28 avril 2022

Ce document a été édité par LATEX 2ε

ii
 Table des matières

1 Complexité :
Conceptes & Outils 1
1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 À propos du temps d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2.2 Analyse du temps d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.3 Rappel sur l’algorithmique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Notions Mathématiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3.1 Complexité asymptotique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3.2 Estimation asympthotique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3.3 Notations de Landau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3.4 Limite supérieure : notation Grand-O . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3.5 Limite inférieure : Notation Grand-Ω . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.6 Notation Grand-Θ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3.7 Utilisation de la limite pour détermier l’ordre . . . . . . . . . . . . . . . . . . . . 9
1.3.8 Propriété . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.3.9 Comparaison d’algorithmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.4 Variation de la complexités d’un algorithme . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.4.1 Complexité au meilleur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.4.2 Complexité au pire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4.3 Complexité en moyenne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4.4 Synthèse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.4.5 Propriété des complexités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.5 Détermination de la complexité d’un algorithme et d’un problème . . . . . . . . . . . . . 13
1.5.1 Classes de complexité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.5.2 Complexité de problèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.5.3 Classification des problèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.5.4 Calcul de la complexité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.6 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2 Calculabilité & décidabilité 21

2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2 Notion de problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2.1 Problèmes abstraits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

iii
TABLE DES MATIÈRES

2.2.2 Codage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.2.3 Les principaux types de problèmes . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.3 Machine de Turing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.3.1 Notion de machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.3.2 Définition de la machine de Turing . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.3.3 Thèse de Church . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.3.4 Machine de Turing déterministe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.3.5 Machine de Turing non déterministe . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.4 Décidabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.4.1 Problèmes décidables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.4.2 Problèmes indécidables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.4.3 Définitions formelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.5 Classe P et Classe NP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.5.1 Classe P . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.5.2 Algorithme de validation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.5.3 Classe NP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

3 La NP-Complétude 31
3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.2 Réduction de problèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.2.1 Réduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.2.2 Réduction polynômiale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.2.3 Exemple de réduction polynômiale simple . . . . . . . . . . . . . . . . . . . . . . 33
3.3 Le problème SAT et le théorème de Levin-Cook . . . . . . . . . . . . . . . . . . . . . . . 34
3.3.1 Présentation du problème SAT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.3.2 Une première série de variante : k-SAT . . . . . . . . . . . . . . . . . . . . . . . . 34
3.3.3 Variantes autour de 2-SAT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.4 NP-complétude . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.4.1 Ensemble complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.4.2 Propriété de la NP-complétude . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.4.3 Preuve de la NP-complétude . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.4.4 Interpréter la NP-Complétude . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.5 Autres problèmes NP-Complets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

iv
 CHAPITRE 1

Complexité :
Conceptes & Outils

1.1 Introduction
L’efficacité d’un algorithme se mesure par le temps d’exécution en fonction de la taille des données
d’entrée et la place mémoire nécessaire à son exécution en fonction de la taille des données d’entrée. Ces
deux fonctions sont appelées complexité de l’algorithme. La détermination de ces fonctions s’appelle
l’analyse de complexité. Dans la suite nous n’étudierons que le temps d’exécution. Pour mesurer le
temps d’exécution comme fonction de la taille des données il faut se donner une unité de mesure. Pour
simplifier le modèle on considère comme temps constant les opérations élémentaires exécutés par une
machine (opérations arithmétiques, logiques, affectations, etc.). L’analyse consiste alors à exprimer le
nombre d’opérations effectuées comme une fonction de la taille des données d’entrée.

1.2 À propos du temps d’exécution

1.2.1 Motivation
L’algorithmique est une discipline sous-jacente à une partie immense de l’économie aujourd’hui.
Le monde du travail a été radicalement transformé pour laisser une large place à l’activité assistée
par ordinateur. la complexité est en quelque sorte la maîtrise de l’algorithmique. Cette science vise à
déterminer, sous un certain nombre de conditions, quel sont les temps de calcul et espace mémoire requis
pour obtenir un résultat donné. Une bonne maîtrise de la complexité se traduit par des applications
qui tournent en un temps prévisible et sur un espace mémoire controlé. A l’inverse, une mauvaise
compréhension de la complexité débouchent sur des latences importantes dans les temps de calculs, ou
encore des débordements mémoire conséquents, qui au mieux, « gêlent »les ordinateurs ( « swap »sur le
disque dur) et au pire font carrément « planter »la machine.
Sur la Figure 1.2 on constate avec une échelle logarithmique la puissance considérable qu’ont acquis
les ordinateurs modernes. On voit que les machines en l’espace de cinquante ans, ont amélioré leur

1
1.2 À propos du temps d’exécution

Figure 1.1 – Puissance de calcul du meilleur ordinateur mondial au fil des ans.

capacités de calcul de moins d’un million d’opérations flottantes par seconde, à plus d’un million de
milliards d’opérations flottantes par seconde.
Cette évolution est était prévisible d’après « la loi de MOORE »Cette révolution oblige à un chan-
gement profond de compréhension des algorithmes qui précisémment commandent ces machines. En
effet, un raisonnement simpliste pourrait consister à penser que la puissance de calcul est pratiquement
infinie.
De fait, beaucoup de programmes peuvent s’exécuter rapidement sur ces supercalculateurs, voire
même sur les ordinateurs que nous cotoyons tous les jours. Cependant, la plupart des calculs que l’ont
peut imaginer ne sont pas, loin s’en faut, simples. Par exemple, beaucoup d’opérations sur une liste font
intervenir l’ordre de la liste en question. Or le nombre d’ordres possibles pour une liste de n éléments, noté
n!, croît excessivement vite. Par exemple, supposons que nous voulions faire sur le meilleur calculateur
existant aujourd’hui, au cours d’une seconde, une opération flottante sur toutes les listes ordonnées
possibles à n éléments. Alors malheureusement, malgré toute notre puissance de calcul, il nous faudrait
nous limiter aux listes à 17 éléments ou moins (17! = 355687428096000 = 3.55 1014 ).
Par ailleurs même si la puissance de calcul va croissant, le coût requis par opération flottante a
tendance à stagner. Cela fait que la consommation énergétique due aux calculs devient phénoménale.
On a estimé que la puissance énergétique totale consommée par les ordinateurs dans le monde était en
2005 de 200T W h, ce qui correspond à la production d’une trentaine de tranches de centrales nucléaires à
800M W att chacune, ou encore, en termes d’empreinte carbone, de 30 million d’automobiles. L’ordinateur
le plus puissant du monde en 2009, le Cray Jaguar, consomme 7M W att pour une puissance de calcul
mesurée de 1, 759T F lops. Ce coût demandé par l’organisation Top500 1 n’est qu’un coût partiel de calcul.
Les spécialistes du calcul haute performance estiment que très bientôt les coûts énergétiques totaux d’un
supercalculateur seraient de l’ordre de 100 MWatt. Tout cela a un coût phénoménal, tant en termes de
ressources financières que planétaires et humaines.
1. http ://www.top500.rog

2
 Chapitre 1. Complexité :
Conceptes & Outils

En résumé, les ressources de calcul d’aujourd’hui sont loin d’être infinies, et il convient de les estimer
avec précision.
Ce cours donne les bases d’une bonne analyse des temps de calcul et donne plusieurs exemples
marquants de calcul complexes réalisés dans un temps maîtrisé.

1.2.2 Analyse du temps d’exécution

Le temps d’exécution d’un programme dépend de plusieurs facteurs :
1. du type d’ordinateur utilisé ;
2. du langage utilisé (représentation des données) ;
3. la hiérarchie mémoire et le profile d’accès aux données ;
4. de la complexité abstraite de l’algorithme sous-jacent.
En général, on veut s’abstraire des trois premières données. Pour se faire, il faut être en mesure de
donner un cadre théorique à l’algorithmique. Pour le premier point ceci se fait par la définition d’un
ordinateur « universel »(une machine de Turing ) qui bien qu’extrêmement simple peut reproduire le
comportement de n’importe quel ordinateur existant.
Pour s’abstraire du second point, on regardera des classes d’équivalence de complexité plutôt que la
complexité elle-même, ce qui permettra de ne pas se préoccuper des constantes qui interviennent dans
les changements de représentations « naturelles »et dans la définition des opérations élémentaires.
Pour le troisième point, on va s’en passer aussi par machine universelle de Turing qui suppose
que la mémoire (« ruban ») est plate et le coût d’accès est uniforme.
Le temps d’exécution d’un programme est du (est la somme) principalement à deux composantes :
— le temps de calcul ;
— le temps d’accès aux données.
Le temps de calcul est le temps prix par le processeur pour exécuter les instructions.
Le temps d’accès aux données est le temps nécessaire pour localiser une données et mettre dans un
registre du processeur. Notons que :
— La hiérarchie de la mémoire est de plus en plus complexe ;
— ce qui améliore la performance de la mémoire ;
— Le temps d’accès n’est pas uniforme.

Exemple 1 ()
Le parcours d’une matrice ligne par ligne ou colonne par colonne donne deux temps d’exécution
très différents. Interpréter ? ?

Plusieurs techniques au niveau matériel ou logiciel sont mises-en-œuvre pour améliorer les temps
exécution :
— récupérer les données par bloc à partir de la mémoire ;
— anticiper sur l’accès aux données : pre-fetching ;
— anticiper sur l’exécution des instruction :exécution spéculative ;
— exécuter plusieurs instructions en même temps : processeurs super-scalaires ;
— profiter de la localité temprelle et spaciale des données pour améliorer le profile d’accès aux
données ;
— etc . . .
La mesure de la complexité d’un algorithme c’est :
1. évaluer les ressources (mémoire et CPU) utiles ;

3
1.2 À propos du temps d’exécution

2. comparer deux algorithmes pour le même problème ;

3. donner une borne sur ce qui est effectivement possible de résoudre.
On considère aujourd’hui qu’on peut réaliser en temps raisonnable 260 opérations. Quant à la mémoire
elle est de l’ordre de 1010 octets. On peut donc s’intéresser à deux types de complexité : en temps et en
mémoire.
La complexité abstraite se mesure en fonction de la taille des entrées. La taille des données est la ou
les dimensions caractéristiques des données
— Pour un entier, il s’agit du nombres de chiffres nécessaires à son écriture. On peut bien sûr imaginer
des circonstances où d’autres facteurs seraient plus importants. Par exemple si un algorithme
factorise un nombre aléatoire de plus en plus grand à chaque fois qu’il rencontre un 9 dans
l’écriture du nombre.
On notera |a|b la taille de a en base b.
On a bien sûr |a|b = blogb ac + 1.
Remarquons qu’un changement de base multiplie la taille par une constante.
— Pour une liste, le paramètre est le cardinal de la liste. On peut noter que ceci est cohérent
avec la complexité pour les entiers, car le tableau pourrait contenir les chiffres du nombre. Dans
l’algorithme de la division euclidienne, on a deux entiers a, b en entrée. On mesurera la complexité
en fonction du sup(|a|, |b|).
— Pour une matrice carrée de taille n c’est n le paramètre. Dans le cas d’opérations sur les matrices,
la complexité sera alors exprimée comme une fonction de n des opérations concernant les coeffi-
cients (qui n’auront pas le même coût élémentaire selon la nature des coefficients - la complexité
en fonction des opérations élémentaires pouvant être alors calculée dans un deuxième temps).
— Pour un polynôme, c’est son degré.
— pour un arbre, on peut considérer son hauteur, ou le nombre de nœuds ;
— Enfin dans certains cas, il n’est pas possible de ne faire intervenir qu’une donnée. Par exemple pour
un graphe, le nombre de sommets et d’arêtes peuvent être tous les deux des facteurs importants
et pourtant complètement indépendants.

1.2.3 Rappel sur l’algorithmique

Algorithme & algorithmique

Un algorithme est une suite ordonnée d’opérations ou d’instruction écrites pour la résolution d’un
problème donné. Un algorithme est une suite d’actions que devra effectuer un automate pour arriver à
partir d’un état initial, en un temps fini, à un résultat. L’algorithmique désigne le processus de recherche
d’algorithme.

Structures de données

Une structure de données indique la manière d’organisation des données dans la mémoire. 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. Exemple : 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. Exemple : liste chainée, pile, file, . . .
La notion des pointeurs : nécessité de la gestion des liens entre les données d’un problème en mémoire.

4
 Chapitre 1. Complexité :
Conceptes & Outils

Propriété d’un algorithme

De nombreux outils formels ou théoriques ont été développés pour décrire les algorithmes, les étu-
dier, exprimer leurs qualités, pouvoir les comparer entre eux : Ainsi, pour décrire les algorithmes, des
structures algorithmiques ont été mises en évidence : structures de contrôle (boucle, conditionnelle, ...)
et structures de données (variables, listes, ...). Pour justifier de la qualité des algorithmes, les notions de
correction, de complétude et de terminaison ont été mises en place.
Enfin, pour comparer les algorithmes entre eux, une théorie de la complexité des algorithmes a été
définie.
Terminaison : La terminaison est l’assurance que l’algorithme terminera en un temps fini. Les
preuves de terminaison font habituellement intervenir une fonction entière positive strictement décrois-
sante à chaque « pas »de l’algorithme.
Correction : Étant donnée la garantie qu’un algorithme terminera, la preuve de correction doit
apporter l’assurance que si l’algorithme termine en donnant une proposition de solution, alors cette
solution est correcte - c’est-à-dire qu’elle est effectivement une solution au problème posé.
Complétude : La preuve de complétude garantit que, pour un espace de problèmes donné, l’algo-
rithme, s’il termine, donnera des propositions de solutions
Éfficacité : Il faut que le programme exécute sa tâche avec efficacité c’est à dire avec un coût
minimal. Le coût pour un ordinateur se mesure en termes de temps de calcul et d’espace mémoire
nécessaire.

1.3 Notions Mathématiques

1.3.1 Complexité asymptotique

Soient deux algorithmes A et B résolvant le même problème de complexité respectives 100n et n2 .
Quel est le plus efficace ?
— Le rapport des complexités de B à A est égal à n/100. Donc :
— Pour n < 100, B est plus efficace.
— Pour n = 100, A et B ont la même efficacité.
— Pour n > 100, A est plus efficace.
— Notons que plus n devient grand, plus A est efficace devant B.
Si les tailles sont « petites », la plupart des algorithmes résolvant le même problème se valent. C’est
le comportement de la complexité d’un algorithme quand la taille des données devient grande qui est
important. On appelle ce comportement la complexité asymptotique.

1.3.2 Estimation asympthotique

La complexité d’un algorithme est une estimation (ou approximation) en limite supérieure du temps
nécessaire à l’exécution. On se contente donc de donner des ordres de grandeur (notation grand-O). On
ignore les facteurs constants : un calcul qui prend 10 × n étapes sur une machine A, peut ne prendre
que 5 × n sur une machine B.
On ignore aussi les étapes d’initialisation. Si un calcul prend 2n2 + 5n, on ignore le temps 5n, car il
est négligeable devant 2n2 pour de grandes valeurs de n.

5
1.3 Notions Mathématiques

1.3.3 Notations de Landau

Quand nous calculerons la complexité d’un algorithme, nous ne calculerons généralement pas sa
complexité exacte, mais son ordre de grandeur. Pour ce faire, nous avons besoin des notations asymp-
totiques.

Définition

Soit un problème P de taille n. On note P(n) une instance de P. On veut calculer la complexité
temporelle T (n) de l’algorithme A qui résout P.
Les notations asymptotiques sont définies comme suit :

1.3.4 Limite supérieure : notation Grand-O

Elle sert à estimer le temps d’exécution d’un algorithme. On dit que T (n) est en O(f (n)) si seulement
s’il existe un entier n0 et une constante c > 0 tel que

∀n ≥ n0 , on a : T (n) ≤ cf (n)

O(f (n)) est l’ensemble des fonction T (n) qui peuvent être bornées supérieurement par cf (n) pour
n suffisamment grand.

Exemple 2 (Notation Grand-O)

6 cf (n)

T (n)

-
n0 n

Exemple 3 ()
T (n)= 60n2 + 5n + 1 ∈ O(n2 ).
car on peut trouver c = 66 et n0 = 1 / ∀n ≥ 1 on a T (n) ≤ 66n2 .

La notation grand-O peut être obtenue à partir de l’expression d T (n) en ne conservant que le terme
le plus fort de l’expression est ignorer les autres.

Exemple 4 ()

6
 Chapitre 1. Complexité :
Conceptes & Outils

T (n) = 3n2 + 10n + 1 → T (n) =O(n2 )

T (n) = n3 + 10000n → T (n) =O(n3 )
T (n) = 25 → T (n) = O(1) : le nombre d’operations excutees
ne depend pas de la taille du probleme
T (n) = 3log(n) + 10 → T (n) =O(log(n))

Exemple 5 ()
On suppose qu’on dispose d’un algorithme dont le temps d’exécution est décrit par la fonction
T (n) = 3n2 + 10n + 10. L’utilisation des règles de la notation O nous permet de simplifier en :

O(T (n)) = O(3n2 + 10n + 10) = O(3n2 ) = O(n2 )

Pour n = 10 nous avons :
— Temps d’exécution de
3(10)2
3n2 : = 73, 2%
3(10)2 + 10(10) + 10
— Temps d’exécution de
10(10)
10n : = 24, 4%
3(10)2 + 10(10) + 10
— Temps d’exécution de
10
10 : = 2, 4%
3(10)2 + 10(10) + 10
Le poids de 3n2 devient encore plus grand quand n = 100, soit 96, 7% ⇒ on peut négliger les
quantités 10n et 10. Ceci explique les règles de la notation O.

1.3.5 Limite inférieure : Notation Grand-Ω

La notation O permet de trouver un majorant. Il existe aussi une autre notation qui permet de
trouver un minorant. C’est la notation « Omega ».

Définition

Une fonction T (n) ∈ Ω(f (n)), si et seulement si ∃ deux constantes n0 et c > 0 telles que :

∀n ≥ n0 , on a T (n) ≥ cf (n)

Ω(f (n)) est l’ensemble de toutes les fonctions T (n) bornées inférieurement par cf (n) pour n suffisament
grand.

7
1.3 Notions Mathématiques

Exemple 6 (Notation Grand-Ω)

6 T (n)

cf (n)

-
n0 n

1.3.6 Notation Grand-Θ

Si une fonction peut être majorée et minorée par une même fonction en notation asympthotique,
alors on parle d’ordre exacte (notation « Théta »).

Définition

Une fonction T (n) ∈ Θ(f (n)) si et seulement si elle vérifie à la fois T (n) ∈ O(f (n)) et T (n) ∈
Ω(f (n)). C’est-à-dire ∃ deux constantes c1 et c2 telles que :

∀n ≥ n0 , on a c1 f (n) ≥ T (n) ≥ c2 f (n)

Exemple 7 (Notation Grand-Θ)

c2 f (n)
6
T (n)

c1 f (n)

-
n0 n

Application 1 ()
Soit T (n) = 60n2 + 5n + 1
Montrer que T (n) ∈ Θ(n2 )

8
 Chapitre 1. Complexité :
Conceptes & Outils

1.3.7 Utilisation de la limite pour détermier l’ordre



 0 alors g(n) ∈ O(f (n))



g(n) 
lim = c>0 alors g(n) ∈ Θ(f (n))
n→+∞ f (n) 




+∞ alors g(n) ∈ Ω(f (n))


Exemple 8 ()
√
Soient f (n) = n log(n) + log(n) et g(n) = n log(n)

f (n)
⇒ f (n) = Ω(g(n)) car lim → +∞
n→+∞ g(n)

Exemple 9 ()
n3
Soient f (n) = 2 et g(n) = 37n2 + 120n + 17

Monter que g(n) = O(f (n)) et f (n) n’est pas O(g(n)).

1.3.8 Propriété
— Reflèxivité
f (n) = O(f (n))
— Transitivité
f (n) = O(g(n)) et g(n) = O(h(n)) alors f (n) = O(h(n))
de même pour Ω et Θ
— Produit par un scalaire
a > 0, a O(f (n) = O(f (n))
— Somme

O(f (n) + g(n)) = O( max (f (n), g(n)))

n→∞

exemple : O(n2 + n) = O(n2 ) et O(n log(n) + n) = O(n log(n))

— Produit
O(f (n)) × O(g(n)) = O(f (n).g(n))
— Symétrie Elle n’est vraie qu’avec Θ :

f (n) = Θ(g(n)) ⇔ g(n) = Θ(f (n))

Par contre,
f (n) = Ω(g(n) ⇔ g(n) = O(f (n))

9
1.4 Variation de la complexités d’un algorithme

1.3.9 Comparaison d’algorithmes

Si deux algorithmes permettent de résoudre le même problème ont des complexités différentes, alors
celui qui possède la complexité la plus petite sera dit plus efficace asympthotiquement. Mais, il est
possible que pour de petites tailles d’entrées l’autre soit plus rapide à l’exécution.

Exemple 10 ()
Considérons deux algorithmes A et B résolvent un même problème telles que : TA (n) = 50n2 et
TB (n) = n3
On’a TA (n) = O(n2 ) et TB (n) = O(n3 )
A est meilleurs asympthotique que B.

Mais, sur une entrée de taille 10 :

TA (10) = 5000 et TB (10) = 1000 ⇒ B est plus efficace.

Remarque

Il faut faire attention aux facteurs constants très grands.

Un algorithme au temps d’exécution 100000000.n est en O(n) et peut être moins efficace qu’un autre
au temps d’exécution en 2n2 qui est en O(n2 ), même pour une entrée de taille importante.

1.4 Variation de la complexités d’un algorithme

La complexité d’un algorithme est la mesure du nombre d’opérations fondamentales qu’il effectue
sur un jeu de données. La complexité est exprimée comme une fonction de la taille du jeu de données.
La complexité d’un algorithme est souvent déterminée à travers une description mathématique du
comportement de cet algorithme.
Soit Dn l’ensemble des données de taille n et soit C(d) le coût d’exécution de l’algorithme sur la
donnée d de taille n.
On définit plusieurs mesures pour caractériser le comportement d’un algorithme.

1.4.1 Complexité au meilleur

Définition

La complexité au meilleur, ou complexité dans le meilleur cas, est le plus petit nombre d’opérations
qu’aura à exécuter l’algorithme sur un jeu de données de taille fixée, ici à n :

Tmin (n) = min C(d)

d∈Dn

Avantage

C’est une borne inférieure de la complexité de l’algorithme sur un jeu de données de taille n.

10
 Chapitre 1. Complexité :
Conceptes & Outils

1.4.2 Complexité au pire

Définition

La complexité au pire, ou complexité dans le pire cas, dite aussi cas le plus défavorable (worst-case
en anglais), est le plus grand nombre d’opérations qu’aura à exécuter l’algorithme sur un jeu de données
de taille fixée, ici à n :

Tmax (n) = max C(d)

d∈Dn

Avantage

Il s’agit d’un maximum, et l’algorithme finira donc toujours avant d’avoir effectué Tmax (n) opérations.

Inconvénient

Cette complexité peut ne pas refléter le comportement « usuel »de l’algorithme, le pire cas pouvant
ne se produire que très rarement, mais il n’est pas rare que le cas moyen soit aussi mauvais que le pire
cas.

1.4.3 Complexité en moyenne

Définition

La complexité en moyenne est la moyenne des complexités de l’algorithme sur des jeux de données
de taille n :
X
Tmoy (n) = P r(d)C(d), d ∈ Dn

où P r(d) est la probabilité d’avoir la donnée d en entrée de l’algorithme.

Avantage

Elle reflète le comportement « général »de l’algorithme si les cas extrêmes sont rares ou si la com-
plexité varie peu en fonction des données.

Inconvénient

La complexité en pratique sur un jeu de données particulier peut être nettement plus importante que
la complexité en moyenne, dans ce cas la complexité en moyenne ne donnera pas une bonne indication
du comportement de l’algorithme.
En pratique la complexité en moyenne est beaucoup plus difficile à déterminer que la complexité dans
le pire cas, d’une part parce que l’analyse devient mathématiquement difficile, et d’autre part parce qu’il
n’est pas toujours facile de déterminer un modèle de probabilités adéquat au problème.

Définition

Si toutes les configurations des données de taille fixée n sont équiprobables, la complexité en moyenne
s’exprime en fonction du nombre |Dn | de données de taille n :

11
1.4 Variation de la complexités d’un algorithme

1 X
Tmoy (n) = C(d)
|Dn |
d∈Dn

Souvent on partitionne l’ensemble Dn des configurations de taille n selon leur coût, et on évalue la
probabilité P r(Dni ) de chaque classe Di − n des configurations de taille n de coût i.
La complexité en moyenne devient alors :

X
Tmoy (n) = P r(Dni )C(Dni )
i ⊆Dn
Dn

où C(Dni ) représente le coût d’une donnée quelconque de Dni .

Les séries génératrices constituent un outil mathématique puissant pour calculer la complexité des
algorithmes.

Attention

Ce n’est parce qu’un algorithme est meilleur en moyenne qu’un autre en moyenne, qu’il est meilleur
dans le pire des cas.

1.4.4 Synthèse
C’est l’analyse pessimiste ou au pire qui est généralement adoptée.
En effet, de nombreux algorithmes fonctionnent la plupart du temps dans la situation la plus mauvaise
pour eux.
L’analyse au pire des cas donne une limite supérieure de la performance et elle garantit qu’un
algorithme ne fera jamais moins bien que ce qu’on a établi.
Un algorithme est dit optimal si sa complexité est la complexité minimale parmi les algorithmes de
sa classe.
Même si on s’intéresse quasi-exclusivement à la complexité en temps des algorithmes.
Il est parfois intéressant de s’intéresser à d’autres ressources, comme la complexité en espace (taille
de l’espace mémoire utilisé), la largeur de bande passante requise, . . . etc.

1.4.5 Propriété des complexités

Propriété La complexité en moyenne et les complexités extrémales sont liées par la relation :

Tmin (n) ≤ Tmoy (n) ≤ Tmax (n)

Remarque

Si le comportement de l’algorithme ne dépend pas de la configuration des données, ces trois quantités
sont confondues.
Mais en général, ce n’est pas le cas et l’on ne sait pas si le coût moyen est plus proche du coût minimal
ou du coût maximal (sauf si l’on sait déterminer les fréquences relatives des configurations donnant un
coût minimal et celles donnant un coût maximal).

12
 Chapitre 1. Complexité :
Conceptes & Outils

1.5 Détermination de la complexité d’un algorithme et d’un pro-

blème

1.5.1 Classes de complexité

Les algorithmes usuels peuvent être classés en un certain nombre de grandes classes de complexité.
Les complexités les plus utilisées sont :

Classe Complexité Exemple

Constante O(1) Accéder au premier élément d’un ensemble de
données
Logari- O(log n) Couper un ensemble de données en deux par-
thmique ties égales, puis couper ces moitiés en deux
parties égales, etc.
Linéaire O(n) Parcourir un ensemble de données
Quasi- O(n log n) Couper répétitivement un ensemble de don-
linéaire nées en deux et combiner les solutions par-
tielles pour calculer la solution générale ⇑
Quadra- O(n2 ) Parcourir un ensemble de données en utilisant k
tique deux boucles imbriquées k Complexité
Cubique O(n3 ) Multiplier deux matrices carrées k polynômiale
... ... ... k
Polyno-miale O(nP ) Parcourir un ensemble de données en utilisant k
P boucles imbriquées ⇓
... ... ... ⇑
Exponen- O(2n ) Générer tous les sous-ensembles possibles d’un k Complexité
tielle en ensemble de données k exponen-
n k tielle
2
... ... ... k
Exponen- O(nn ) ... k
tielle en ⇓
nn

Table 1.1 – Les classes de complexités

1.5.2 Complexité de problèmes

Définition

la complexité d’un problème est le nombre minimal d’opérations élémentaires à effectuer pour ré-
soudre ce problème : c’est une borne inférieure pour la complexité des algorithmes que l’on peut imaginer
pour traiter ce problème.

13
1.5 Détermination de la complexité d’un algorithme et d’un problème

Figure 1.2 – Les classes de complexité

Optimalité d’un algorithme

Un algorithme résolvant un problème P est dit optimal si on sait que c’est impossible de trouver un
autre résolvant P avec une meilleure complexité.

⇒ Comment voir si un algorithme est optimal ?

Il faut trouver une borne inférieure sur le nombre d’opérations nécessaires pour résoudre P : T (n) ≥ k
pour tous les algorithmes résolvant P.

Exemple 11 ()
Pour la multiplication matricielle, il existe une borne inférieure pour ce problème : n2 .

1.5.3 Classification des problèmes

Nous considérons les problèmes dits « faciles »pour lesquels il existe un algorithme dont le temps
d’exécution est borné par une fonction polynômiale.

Les problèmes dits « difficiles »pour lesquels il n’existe pas un algorithme dont le temps d’exé-
cution est borné par une fonction polynômiale.

14
 Chapitre 1. Complexité :
Conceptes & Outils

1.5.4 Calcul de la complexité

Cas d’une instruction simple

écriture, lecture, affectation

Dans le cas d’uns suite d’instructions simples, on considère la complexité maximale.

Exemple 12 ()

x : entier
y : entier
x←0 /*instruction 1 en O(1) */
y←x2 /*instruction 2 en O(1) */

La complexité de cette séquence vaut

max(O(1), O(1)) = O(1)

Cas d’un traitement conditionnel

Exemple 13 ()

si <condition> alors
<traitement 1>
sinon
<traitement 2>
finsi

La complexité de cette séquence vaut

O(T<condition> ) + max(O(T<traitement 1> ), O(T<traitement 2> ))

Cas d’un traitement itératif

Exemple 14 (Boucle Tant Que)

15
1.6 Exercices

tant que <condition> faire

<traitement>
fintantque

La complexité de cette boucle vaut :

N br_itrations × (O(T<condition> ) + O(T<traitement> )

Exemple 15 (Boucle Pour)

pour i de <ind_Deb> <ind_Fin> faire

<traitement>
finpour

La complexité de cette boucle vaut :

ind_F in
X
T = O(T<traitement> )
i=ind_Deb

1.6 Exercices
Exercice 1 ( pts)

1. Quel est l’intérêt de l’étude de la complexité algorithmique ?

2. Quels sont les types de complexités considérées ?
3. Donner la définition de l’estimation asymptotique, Grand-O.
4. Quelle est la classe de complexité la plus importante ?
5. Donner la complexité de l’algorithme de recherche dichotomique d’un élément dans un tableau
trié de taille n ?
6. Pourquoi distinguer la complexité au meilleur et celle au pire des cas ?

Exercice 2 ( pts)
Sur une machine qui réalise 1010 opérations/sec, calculer les temps d’exécution des algorithmes suivants
selon leurs complexités et la taille des problèmes.
log n n n log n n2 n3 2n
102
105

Exercice 3 ( pts)
Calculer la complexité, en nombre d’opérations arithmétiques, des algorithmes suivants au meilleur et
au pire des cas.
Algo1 :

16
 Chapitre 1. Complexité :
Conceptes & Outils

Pour i de 1 a n faire
A[i] ← 0
Pour j de 1 a n faire
A[i] ← A[i] + B[i, j]
D[i, j] ← 0
Si B[i, j] > 0 alors
Pour k de 1 a n faire
D[i, j] ← D[i, j] + B[i, k] × C[k, j]
Finpour
Sinon D[i, j] ← B[i, j] + C[i, j]
Finpour
Finpour
Algo2 :
Si x > 0 alors
Pour i de 1 a n faire
A[i] ← B[i] × C[i]
Pour j de 1 a n faire
D[i,j] ← 0
Pour k de 1 a j faire
D[i,j] ← D[i,j]+X[i,k]*Y[k ,j]
Finpour
Finpour
Finpour
Sinon
Pour i de 1 a n faire
Pour j de 1 a n faire
D[i,j] ← X[i,j]+Y[i,j]
Finpour
Finpour
Finsi

Exercice 4 ( pts)

1. Soient les deux fonctions suivantes :

3
f (n) = n2
g(n) = 37n2 + 120n + 17
Montrer que :
a. g(n) ∈ O(f (n))
b. f (n) ∈ Ω(g(n))
c. f (n) ∈ O(g(n))
2. En utilisant les limites, trouver une relation, en notation asymptotique, entre les deux fonctions
suivantes :
f (n) = 5n3 + 30n2
g(n) = 2n2 + 3n3 log n
3. En utilisant les propriétés de la notation Grand-O, simplifier les expressions suivantes pour les
cas f (n) = O(1), f (n) = O(n) et f (n) = O(n2 ) :

17
1.6 Exercices

a. O(f (n) log f (n) + n)

b. O(n2 + f (n) log f (n) + n log n + f (n)2 )
c. 3n3 + 2n2 f (n)2 + O(n2 + nf (n))

Exercice 5 ( pts)

1. Proposer une comparaison des deux algorithmes suivants :

A : TA (n) = 100n3
B : TB (n) = n4
2. Qu’est ce qu’un problème Difficile ?
3. Peut-on affirmer que l’algo1 de l’exercice 3 est Difficile ? Pourquoi ?

Exercice 6 ( pts)
Énoncer les algorithmes de tri suivants et calculer leurs complexités en terme de comparaisons et d’af-
fectations.

— Tri Bulles
— Tri permutation
— Tri sélection
— Tri insertion
Proposer une estimation asymthotique en notation O() de ces quantités.

Discuter des cas les plus favorables et plus défavorables.

Exercice 7 ( pts)
Partant de
f (n) = O(g(n)) ⇒ O(f (n) + g(n)) = O(g(n))

simplifier les expressions suivantes :

— O(n + log n)
— O(n2 + n.log n)
— O(nk + nr log n), k, r entiers > 0 ;
— O(log n + (log log n)2 )
√
— O( logn n + n)
— O(n! + C n ), C entier > 0.

Exercice 8 ( pts)
Un algorithme résolvant un problème associé à un graphe G = (X, U ) est de complexité O(δm + n) où
n = |X| et m = |U | et δ est le maximum des degrés des nœuds.
Discuter et simplifier l’expression O(δm + n).

Exercice 9 ( pts)
Soit une instance P(n) d’un problème P. Soit un algorithme A(n) résolvant P(n). On note |E(n)| le
nombre d’éléments de l’ensemble d’entrée de A(n). A(n) est dit de coût minimum si la complexité C(n)
de A(n) est d’ordre O(|E(n)|).
1. Écrire un algorithme de recherche d’un élément x dans une liste non tirée de taille n. L’algorithme
est-il de coût minimum ?

18
 Chapitre 1. Complexité :
Conceptes & Outils

2. Écrire un algorithme de recherche binaire d’un élément x dans une liste triée de taille n. Quelle
est sa complexité ? Est-il de coût minimum ? Que pensez vous de la définition d’un algorithme de
coût minimum donnée ci-dessus ?
3. Combien de boucles imbriquées doit comporter un algorithme de coût minimum ayant en entrée :
— deux vecteurs d’ordre n ;
— une matrice carrée d’ordre n et un vecteure d’ordre n ;
— une matrice non carrée (m,n) et un vecteur d’ordre n ;
— deux matrices carrée d’ordre n.
Donner dans chaque cas la complexité O(f (n)), f (n) à déterminer.
4. Dans quel cas le tri d’une liste de n éléments peut se faire avec un algorithme de complexité
O(n) ?

Exercice 10 ( pts)
Soit un graphe G = (X, U ) où n = |X| et m = |U | et A la matrice d’adjacence de G. A est une matrice
carrée d’ordre n telle que a(i, j) = 1 s’il exite un arc entre les nœuds i et j, 0 sinon.
On désire calculer le maximum des degrés des n nœuds. Écrire l’algorithme correspondant. Est-il de
coût minimum ?

Exercice 11 ( pts)
Énoncer les algorithmes de tri suivants et calculer leurs complexità s
c en terme de comparaisons et
d’affectations.

— Tri Bulles
— Tri permutation
— Tri sélection
— Tri insertion
Proposer une estimation asymthotique en notation O() de ces quantités.

Discuter des cas les plus favorables et plus défavorables.

19
1.6 Exercices

20
 CHAPITRE 2

Calculabilité & décidabilité

2.1 Introduction
Les problèmes de décidablité, de complexité et d’approximation sont au cœur de l’informatique
moderne :
— Est-ce qu’un problème est résoluble par une machine ?
— Est-ce qu’un problème est résoluble par une machine en un temps raisonnable ?
— Quelle est la difficulté pour trouver une solution approchée à un problème qui n’est pas résoluble
par une machine en un temps raisonnable ?
— Classer les problèmes en fonction de leur difficulté structurelle indépendamment des technologies
actuelles ou futures ;
— Classer les problèmes en fonction de la difficulté du calcul d’une solution approchée.
D’où la question : tous les problèmes peuvent-ils être résolus en temps polynomial ?
— Non, car certains ne peuvent pas être résolus (non décidabilité de la terminaison) ;
— Non, a priori, car il y a des problèmes pour lesquels on ne connaît que des algorithmes de coût
exponentiel.
On aimerait donc savoir si un problème peut ou non être résolu par un algorithme polynomial : s’il
ne peut exister d’algorithme polynomial pour le résoudre, il vaudra alors sans doute mieux développer
un algorithme d’approximation (ou heuristique) polynomial qu’un algorithme de résolution exact à la
complexité super-polynomiale. La question de l’existence d’un algorithme de résolution de complexité
polynomiale nous amène à définir des classes de complexité : intuitivement on aimerait avoir une classe
des programmes que l’on peut résoudre en temps polynomial, une classe de problème plus compliqués,
et un moyen de déterminer à quelle classe appartient un problème.

2.2 Notion de problème

Il faut tout d’abord pouvoir représenter l’ensemble des instances d’un problème et la question qu’on
se pose.

21
2.2 Notion de problème

Exemple 1 ()
Décider si un nombre est premier.
— Le langage des instances est N, il peut être représenté par l’ensemble L = {0, 1}∗ ;
— Décider la primalité revient à construire une machine M qui calcule la fonction f de L dans
{0, 1} définie par :
(
1 si x est premier
f (x) =
0 sinon

— Évaluer la complexité temporelle de ce problème consiste à estimer le temps mis par le

fonctionnement de la machine en fonction de la taille de l’entrée : (|x| = blog2 (x)c + 1) ;
Ce problème peut être résolu en temps O(|x|6 ) (Agrawal, Kayal et Saxena, août 2002).

2.2.1 Problèmes abstraits

Définition

On définit un problème abstrait Q comme une relation binaire sur un ensemble I d’instances d’un
problème et un ensemble S de solutions de ce problème.

Exemple 2 ()
Prenons le problème PLUS-COURT-CHEMIN qui consiste à trouver le plus court chemin entre deux
sommets d’un graphe.
— Une instance de ce problème est un triplet composé d’un graphe et de deux sommets.
— Une solution du problème est une séquence de sommets du graphe (si la séquence est vide,
il n’existe pas de chemin du graphe reliant les deux sommets).
— Le problème lui-même est la relation qui associe à une instance donnée une ou plusieurs
solutions.

Restriction aux problèmes de décision

Dans le cadre de la théorie de la NP-complétude, nous nous restreindrons aux problèmes de décision,
c’est-à-dire ceux dont la solution est soit vrai soit faux.

Exemple 3 ()
prenons le problème CHEMIN qui répond à la question « étant donné un graphe G, deux sommets u
et v et un entier positif k, existe-t-il dans G un chemin de u à v de longueur au plus k ? ».

Problèmes d’optimisation

De nombreux problèmes abstraits ne sont pas des problèmes de décisions mais des problèmes d’op-
timisation. Pour leur appliquer la théorie de la NP-complétude, le plus souvent on les reformulera sous
la forme d’un problème d’optimisation en imposant une borne sur la valeur à optimiser, comme nous
l’avons fait en passant du problème PLUS-COURT-CHEMIN au problème CHEMIN.
Ce passage aux problèmes de décision n’est pas restrictif :

22
 Chapitre 2. Calculabilité & décidabilité

1. si on sait reésoudre le problème d’optimisation en temps polynomial alors on sait résoudre le

problème de décision en temps polynomial aussi :
a. résoudre problème optimisation en calculant la solution S ;
b. comparer S à la proposition de solution K et répondre par la suite au problème de dècision
associé.
2. si le problème de décision est difficile alors le problème d’optimisation est difficile aussi.

2.2.2 Codage
Définition

Pour qu’un programme informatique puisse résoudre un problème abstrait, il faut que ces instances
soient représentées sous une forme compréhensible par le programme.
On appelle codage d’un ensemble S d’objets abstraits une application e de S dans l’ensemble des
chaînes binaires (ou dans l’ensemble des chaînes d’un alphabet fini quelconque). Exemple : le classique
codage des entiers sous forme binaire. . . Un algorithme informatique qui « résout »un certain problème
de décision prend en fait en entrée un codage d’une instance de ce problème. Un problème dont les
instances forment l’ensemble des chaînes binaires est appelé problème concret.
On dit qu’un algorithme résout un problème concret en O(T (n)) quand, sur une instance i du
problème de longueur n = |i|, l’algorithme est capable de produire la solution en au plus O(T (n)).
Un problème concret est donc résoluble en temps polynomial s’il existe un algorithme permettant
de le résoudre en temps O(nk ) pour une certaine constante k.

L’importance des codages

Pour quoi s’embêter avec des codages plutôt que de définir directement la complexité d’un problème
abstrait ? Parce que la complexité dépend du codage. . .Pour le voir, considérons un algorithme qui prend
comme unique entrée un entier k, et dont le temps d’exécution est en Θ(k).
— Si l’entier k est fourni en unaire (son codage est alors une chaîne de k 1), le temps d’exécution
de l’algorithme est en O(n) sur des entrées de longueur n, et l’algorithme est de complexité
polynomiale.
— Si l’entier k est fourni en binaire, la longueur du codage est alors de n = blog2 kc + 1, et le temps
d’exécution de l’algorithme est en Θ(k) = Θ(2n ), et l’algorithme est de complexité superpolyno-
miale.
On ne peut donc pas parler de la complexité de la résolution d’un problème abstrait sans spécifier son
codage.

2.2.3 Les principaux types de problèmes

— Problème de décision :
Instance : un langage L ⊆ A∗ ;
Question : tester si le mot x ∈ A∗ appartient à L ;
— Problème de recherche :
Instance : une partie R ⊆ A ∗ ×B∗ et un mot x ∈ A∗ ;
Question : trouver un y ∈ B∗ tel que (x, y) ∈ R ;
— Problème d’optimisation :
Instance : une fonction f de A ∗ ×B∗ dans Q et un mot x ∈ A∗ ;
Question : trouver y ∈ B∗ tel que f (x, y) = maxz (f (x, z)) [ou f (x, y) = minz (f (x, z))] ;

23
2.3 Machine de Turing

— Problème de seuil associé au problème d’optimisation : C’est le problème de décision du langage

LS des mots x tels qu’il existe y vérifiant f (x, y) ≥ S (ou f (x, y) ≤ S).

2.3 Machine de Turing

2.3.1 Notion de machine
Intuitivement, un dispositif de calcul peut être décrit indépendamment de toute réalisation physique
comme un dispositif ayant les propriétés suivantes :
— à chaque instant, le dispositif se trouve dans un état bien précis et le nombre d’états possibles
est fini. Un état particulier désigne le début du calcul ;
— le dispositif comporte une mémoire qui peut contenir un nombre éventuellement infini d’objets
finis mais qui à chaque instant n’en contient qu’un nombre fini ;
— le dispositif est muni d’un programme qui est un objet fini contrôlant les changements d’états
possibles et les modifications de la mémoire ; à chaque instant le programme choisit l’ensemble
des actions à effectuer en fonction :
— du contenu de la mémoire ;
— de l’état dans lequel se trouve la machine ;
— la machine s’arrête si cet ensemble est vide.
Une convention est associée au dispositif pour caractériser :
— la partie de la mémoire qui correspond aux données qui vont être soumises au calcul ;
— la partie de la mémoire qui contiendra les données du résultat ;
— la manière dont les données sont représentées dans la mémoire.

2.3.2 Définition de la machine de Turing

Une machine de Turing est un modèle simplifié d’ordinateur qui permet d’évaluer ce qui est faisable
en matière de calcul. Bien que très élémentaire, elle représente une première approche fondamentale
pour la théorie de la compléxité.
La machine, comme indiqué sur la figure 3.3, est un ordinateur qui lit et écrit des symboles sur une
bande enregistreuse de longueur infinie, et le fait à la position du curseur où elle se trouve. La machine
lit et écrit un seul symbole à la fois en suivant des règles précises. Ces règles dépendent d’un « état »dans
lequel se trouve la machine, ainsi que du symbole qui est lu. La machine possède un nombre fini d’états.

Figure 2.1 – Une machine de Turing

Formellement, on se donne donc, pour définir la machine de Turing :

24
 Chapitre 2. Calculabilité & décidabilité

1. un ensemble Q d’états,
2. un ensemble Σ de symboles,
3. un état initial ι,
4. un symbole distingué t ∈ Σ (appelé le symbole « blanc »),
5. un ensemble d’états finaux A ⊆ Q,
6. une fonction de transition δ, de Q × Σ dans Q × Σ × {−1, +1}.
Son sens est le suivant :
si la machine est dans l’état q0 et qu’elle lit le symbole σ0 à la position courante du curseur, et en
écrivant δ(q0 , σ0 ) = (q1 , σ1 , 1 ), alors la machine va écrire à l’emplacement du curseur le symbole
σ1, passe à l’état q1 .
Par ailleurs, elle avance le curseur sur la bande d’une case si 0 = +1 et le recule d’une case si
0 = −1.

2.3.3 Thèse de Church

Tout algorithme peut être représenté sous la forme d’une table de transitions d’une machine de
Turing.
L’idée sous-jacente est que les machines de Turing, malgré leur apparente simplicité, possèdent en
fait une puissance suffisante pour permettre de résoudre tout problème pouvant être traité de façon
automatique.
Une formulation savante de la thes̀e de Church est donc : « tout problème calculable est Turing
calculable »

Exemple 4 ()
La machine de Turing qui suit possède un alphabet {’0’, ’1’}, ’0’ étant le « blanc ». On suppose que
le ruban contient une série de ’1’, et que la tête de lecture/écriture se trouve initialement au-dessus
du ’1’ le plus à gauche.
Cette machine a pour effet de doubler le nombre de ’1’, en intercalant un ’0’ entre les deux séries.
Par exemple, « 111 »devient « 1110111 ». L’ensemble d’états possibles de la machine est e1, e2, e3,
e4, e5 et l’état initial est e1.

La table d’actions est la suivante :

L’exécution de cette machine pour une série de deux ’1’ serait (la position de la tête de lecture/écriture
sur le ruban est inscrite en caractères gras et souslignés) :
Le comportement de cette machine peut être décrit comme une boucle :
— Elle démarre son exécution dans l’état e1, remplace le premier 1 par un 0.
— Puis elle utilise l’état e2 pour se déplacer vers la droite, en sautant les 1 (un seul dans cet exemple)
jusqu’à rencontrer un 0 (ou un blanc), et passer dans l’état e3.
— L’état e3 est alors utilisé pour sauter la séquence suivante de 1 (initialement aucun) et remplacer
le premier 0 rencontré par un 1.
— L’état e4 permet de revenir vers la gauche jusqu’à trouver un 0, et passer dans l’état e5.
— L’état e5 permet ensuite à nouveau de se déplacer vers la gauche jusqu’à trouver un 0, écrit au
départ par l’état e1.
— La machine remplace alors ce 0 par un 1, se déplace d’une case vers la droite et passe à nouveau
dans l’état e1 pour une nouvelle itération de la boucle.

25
2.3 Machine de Turing

Ancien état Symbole lu Symbole écrit Mouvement Nouvel état

0 arrêt
e1
1 0 droite e2
1 1 droite e2
e2
0 0 droite e3
1 1 droite e3
e3
0 1 gauche e4
1 1 gauche e4
e4
0 0 gauche e5
1 1 gauche e5
e5
0 1 droite e1

Table 2.1 – Exemple de machine de Turing

Étape État Ruban

1 e1 11
2 e2 01
3 e2 010
4 e3 0100
5 e4 0101
6 e5 0101
7 e5 0101
8 e1 1101
9 e2 1001
10 e3 1001
11 e3 10010
12 e4 10011
13 e4 10011
14 e5 10011
15 e1 11011

Table 2.2 – Exemple d’exécution d’une machine de Turing

Ce processus se répète jusqu’à ce que e1 tombe sur un 0 (c’est le 0 du milieu entre les deux séquences
de 1) ; à ce moment, la machine s’arrête.

2.3.4 Machine de Turing déterministe

Dans le cas d’ une machine de Turing déterministe, le fonctionnement est le suivant.
On fournit à la machine le problème initial, par exemple le graphe sur lequel un chemin eulérien 1
ou hamiltonien 2 doit être calculé, ce qui est exprimé avec un certain encodage sur les cases 0 à n de la
bande de la machine de Turing, et la machine effectue son calcul, et on se demande si on peut garantir
que la machine va au bout d’un certain temps répondre par VRAI ou FAUX sur la nature de problème.
1. On qualifie d’eulérien, un chemin qui passe une et une seule fois par chaque arc du graphe qui lui sert de support.
2. On qualifie d’hamiltonien, un chemin qui passe une et une seule fois par chaque sommet du graphe qui lui sert de
support.

26
 Chapitre 2. Calculabilité & décidabilité

Par exemple à la question existe t-il un chemin eulérien ou hamiltonien, va t-elle répondre VRAI ou
FAUX) dans un temps déterminé.

2.3.5 Machine de Turing non déterministe

Si par contre on s’intéresse à une machine de Turing non-déterministe, alors on s’autorise, une
fois que le problème a été écrit, à rajouter des cases magiques par exemple avant la case 0, qui encode
une solution devinée du problème. Dans le cas d’une question sur l’existence d’un chemin, on pourra
fournir l’encodage complet d’un chemin donnant la solution du problème.
La machine vérifie que les cases magiques fournissent bien une solution au problème, et répond par
VRAI ou FAUX.
La question est de savoir si, étant donné un problème ayant une solution, il existe au moins une
affectation des cases magiques qui atteste de l’existence de cette solution en un temps déterminé.
Par exemple, si un chemin eulérien ou hamiltonien existe dans le graphe, si on fournit à la machine
sur sa bande l’encodage du graphe et d’un chemin valide, la machine peut-elle en un temps déterminé
attester la validité de ce chemin ?
Dans les deux cas, lorsque la machine est dans un état final (q ∈ A), elle s’arrête.
La carartéristique de non-déterminisme est importante et est à l’origine des classes de complexité.
Le déterminisme est défini par unicité du choix que l’on peut obtenir à chaque transition. On peut
au contraire envisager plusieurs transitions possibles à chaque étape : on a lors potentiellement un grand
nombre d’exécution possibles (certaines pouvant être infinies) à partir d’un seul mot d’entrée, et on dira
que le mot est accepté s’il est accepté dans au moins une de ces exécutions. On peut alors montrer, comme
pour les automates, que cet ajout ne change pas la puissance d’expression des machines de Turing : en
introduisant un nombre suffisant de nouveaux états, on peut transformer toute machine non-deterministe
en une machine déterministe qui reconnaît le même langage (mais en un temps potentiellement beaucoup
plus long).
Il est évident qu’un langage accepté par une TM 3 déterministe peut l’être par une TM non-
déterministe. Il a été démontré que la réciproque est vraie aussi.

Theorème 2.3.1. Les langages reconnus par les automates finis déterministes sont exactement ceux
reconnus par les automates finis non-déterministes.

Theorème 2.3.2. Les langages reconnus par un automate fini sont exactement ceux décrits par les
expressions régulières

2.4 Décidabilité
2.4.1 Problèmes décidables
Un codage des instances d’un probème conduit à une représentation des données en mémoire. Si nous
pensons à un modèle d’exécution sur un ordinateur, au niveau élémentaire le codage d’une instance est
une suite de bits à 0 ou à 1. Cette suite de bits est un mot sur l’alphabet Σ = {0, 1}. L’ensemble des
mots codants les instances du problème défini un langage.
Le problème de la reconnaissance d’un langage L consiste à décider pour tout mot ω ∈ Σ∗ si ω
appartient à L. La reconnaissance de langage est l’abstraction par rapport un codage de la résolution
d’un problème de désicion Π, un codage représente chacune des instances comme un mot sur un alphabet
Σ de symboles.
3. Turing Machine

27
2.4 Décidabilité

Nous pouvons ainsi associer à Π le langage LΠ constitué de tous les mots codants à travers un codage
naturel de Π les instances positives. Décider pour une instance x si x ∈ YΠ est alors équivalent à décider
pour le mot ω encodant x si ω ∈ LΠ .

Figure 2.2 – Équivalence entre un problème de décision et la reconnaissance d’un langage

2.4.2 Problèmes indécidables

Les machines que nous avons construit permettent de répendre oui pour tous les mots d’un langage
et non pour tous les mots n’appartenant pas à ce langage. On dit que la machine accepte ou n’accepte
pas ces mots.
Il se peut cependant que la machine ne s’arrête pas pour un mot n’appartenant pas au langage,
qu’elle ne puisse pas décider si un mot appartient à ce lanage. Mais comment discerner si une exécution
est infinie, ou simplement très longe ? Les modèle de calcul ont intéressé les logiciens et mathématiciens
depuis le début du siècle dernier avant même l’aaparaition des machines.
Depuis Hilbert, jusqu’à Turing, Church, Godel, Post dans les années trente... Avant même l’ap-
paraition des ordinateurs, Godel montrait l’existence d’énoncés impossibles à démontrer. La notion
d’indicidabilité a été largement utilisée en Informatique depuis. Établir qu’un problème est indécidable
est plus fort que dire simplement qu’on ne sait pas résoudre.

Exemple 5 (Halting problem)

Instance : Un programme écrit dans un langage donné et une entrée
Question : Le programme s’arrête t-il sur cette entrée ?

Le Halting problem ou problème d’arrêt n’est pas une procédure effective, il ne connaît pas en
effet pas de solution calculable, il est indécidable.

2.4.3 Définitions formelles

Définition : traitabilité

Un problème est dit triatable s’il admet un algorithme polynomial pour le résoudre.

28
 Chapitre 2. Calculabilité & décidabilité

Définition : décidabilité

1. Un problème est décidable si et seulement si il existe une machine de Turing qui résout le problème
et qui s’arrête toujours.
2. Un problème est dit indécidable si il n’est pas décidable.
3. Un problème est semi-décidable si il existe une machine de Turing qui le résout. Il n’y a aucune
condition sur l’arrêt.

Figure 2.3 – Discussion de la décidabilité des problèmes

2.5 Classe P et Classe NP

2.5.1 Classe P
On définit la classe T IM E(f (n)) comme l’ensemble des langages pouvant être décidés en temps
O(f (n)) par une machine de Turing déterministe.
La classe de complexité P est l’ensemble des problèmes concrets de décision qui sont résolubles en
temps polynomial. Autrement dit, la classe P est l’ensemble des problèmes pour lesquels une machine
de Turing déterministe peut trouver une solution en un temps polynomial.

Définition

La classe P est l’ensemble des langages L pouvant être décidés par une machine de Turing déterministe
polynomiale.
[
P = T IM E(nk )
k

2.5.2 Algorithme de validation

Considérons le problème CHEMIN et une de ses instances (G, u, v, k). La question qui nous intéresse
est donc : existe-t-il dans le graphe G un chemin reliant les sommets u et v dont la longueur est inférieure
ou égale à k ? Si l’on se donne également un chemin p de u vers v, on peut facilement vérifier que la
longueur de p est au plus égale à k et, le cas échéant on peut voir p comme un certificat que le problème
de décision CHEMIN renvoie vrai sur cette instance. Ici, la validation du fait que le problème concret de
décision CHEMIN renvoie vrai sur l’instance (G, u, v, k), validation effectuée à partir du certificat p, prend
autant de temps que la résolution du problème à partir de rien. Ce n’est pas toujours le cas.

29
2.5 Classe P et Classe NP

Exemple 6 ()
Il est trivial de vérifier qu’un chemin est un cycle hamiltonien (cycle simple contenant tous les som-
mets) d’un graphe donné alors que l’on ne sait résoudre ce problème qu’en temps super polynomial.

Définition

Soit un problème concret de décision Q. Un algorithme de validation pour Q est un algorithme de

décision A à deux arguments, où un argument est une instance x du problème, et où l’autre argument
est un certificat y. L’algorithme A valide l’entrée x si et seulement si il existe un certificat y tel que
A(x, y) = vrai. Bien évidemment, l’algorithme A ne doit valider que les instances x de Q pour lesquelles
Q(x) est vrai. Si Q(x) = faux, il ne doit pas y avoir de certificat validant x.

2.5.3 Classe NP
Nous définissons la classe N T IM E(f (n)) comme l’ensemble des langages pouvant être reconnus en
temps O(f (n)) par une machine de Turing non déterministe.
Rappelons qu’une TM non déterministe accepte un mot simplement s’il existe une exécution accep-
tant ce mot. Ainsi une TM non déterministe T reconnait le langage L en temps f (n) si :
— Pour tout mot ω ∈ L, il existe une exécution de T acceptant ω en au plus f (|ω|) transitions.
— Pour tout mot ω ∈ / L, aucune exécution de T (quelle que soit sa longueur) ne conduit à un état
accepteur.
La classe de complexité NP est l’ensemble des problèmes concrets de décision Q pour lesquels il
existe un algorithme polynomial de validation A.

∃c ≥ 0 telle que ∀x instance de Q : Q(x) = vrai ⇐⇒ ∃y certificat , |y| = O(|x|c ), A(x, y) = vrai

Autrement dit, la classe NP est l’ensemble des problèmes pour lesquels une machine de Turing
non-déterministe peut valider une solution en temps polynomial.

Définition

La classe NP est l’ensemble des langages L pouvant être reconnus par une machine de Turing non
déterministe polynomiale. [
NP = N T IM E(nk )
k

Il est clair que nous avons l’inclusion P ⊆ N P . En effet, la machine de Turing déterministe est un
cas particulier de machine de Turing non déterministe. . .
Le problème ouvert le plus célèbre de la complexité est de savoir si P = N P ou si cette inclusion est
stricte.

30
 CHAPITRE 3

La NP-Complétude

3.1 Introduction
Le principe de l’étude de la complexité est de classifier les problèmes par rapport au critère de temps
d’exécution sur une machine de Turing.

Les deux classes P et NP que nous avons définies ne semblent pas assez fines pour discriminer la
difficulté des problèmes.

Nous aimerions introduire une relation d’ordre sur les problèmes (langages), signifiant qu’un pro-
blème est plus facile qu’un autre (que le langage correspondant est plus facile à décider que l’autre).

Cette relation d’ordre est définie par la réduction polynômiale.

3.2 Réduction de problèmes

Nous avons besoin de pouvoir comparer la difficulté de problèmes.

Intuitivement, un problème Π1 peut être ramené à un problème Π2 si une instance quelconque x de

Π1 peut être « facilement reformulée »comme une certaine instance y de Π2 .

Dans ce cas, la résolution du problème Π2 (y) nous fournira la solution du problème Π1 (x) et le
problème Π1 n’est, dans un certain sens, « pas plus difficile à résoudre »que le problème Π2 .

3.2.1 Réduction
Certains problèmes peuvent être résolus s’il on dispose d’un algorithme résolvant un autre problème.

31
3.2 Réduction de problèmes

Exemple 1 ()
Problème 1 : trouver le maximum d’une suite de nombres ;
Problème 2 : trier en ordre décroissant une suite de nombres.

Si l’on dispose d’un algorithme résolvant le problème 2, alors on a aussi un algorithme résolvant
le problème 1 (pas nécessairement le meilleur)

Les techniques de réduction déjà beaucoup utilisée pour déterminer la (non) calculabilité de pro-
blèmes

3.2.2 Réduction polynômiale

Un ensemble A est polynomialement réductible à un ensemble B (A p B) s’il existe une fonction f
de complexité temporelle polynomiale telle que

a ∈ A ⇔ f (a) ∈ B

Autrement dit, si le mot a est une solution pour l’algorithme A alors f (a) est une solution pour
l’algorithme B.

De manière plus formelle, si le mot a est accepté par la machine de Tuing qui décrit A alors f (a) est
accepté par la machine de Turing qui décrit B.
Du point de vue des problèmes, f est une réduction polynomiale du problème Π au problème Π0 si
elle est une réduction polynomiale entre les langages correspondants.

La réduction f transforme toutes les instances positives Π en instances positives de Π0 , et toutes

instances négatives de Π en instances négatives de Π0 .

L’existence d’une réduction polynômiale de Π vers Π0 montre que Π0 est au moins aussi difficile
que Π.
En effet, si Π peut être résolu en temps polynomial, alors Π0 peut l’être aussi ;

si par contre Π requiert un temps exponentiel, alors Π0 ne peut être résolu par un algorithme poly-
nômial.

Notons bien que le sens premier de la réduction de Π vers Π0 est encore plus fort :

une réduction prouve qu’à une transformation polynomiale près des instances, c’est-à-dire à un
codage naturel près de Π, le problème Π est simplement un sous-problème de Π0 .
D’un point de vue algorithmique, une réduction est un « pre-processing »des instances du problème
Π, qui permet d’utiliser tout algorithme polynomial de résolution pour Π0 pour résoudre Π en temps
polynomial.

On notera Π p Π0 si il existe une réduction polynomiale de Π vers Π0 . Nous dirons que Π se réduit
à Π0 .

32
 Chapitre 3. La NP-Complétude

Propriétés

— p est une relation réflexive et transitive ;

— Si A p B et B ∈ P Alors A ∈ P ;

— Si A p B et B ∈ NP Alors A ∈ NP ;

— On notera par ≡ l’équivalence associée : A ≡ B si et seulement si A p B et B  A.

3.2.3 Exemple de réduction polynômiale simple

Détaillons un exemple de réduction polynomiale du problème de décision qui cherche à déterminer
si un graphe possède une chaîne hamiltonienne à partir du problème du cycle hamiltonien.

Exemple 2 (HamiltonianPath (HP))

Instance. un graphe G = (V, E) ;
Question. Est-ce que le graphe possède une chaîne hamiltonienne dans G entre x et y (chaîne qui
passe une fois et une seule par tous les sommets du graphe) ?

Pour montrer que nous avons la réduction HP p HC, considérons une instance de HP, c’est-à-dire un
graphe G.

À partir de G nous construisons une instance particulière f (G) de HC en ajoutant à G un nouveau

sommet x relié à tous les autres :

f (G) = (V ∪ x, E ∪ (x, y)∀y ∈ V ).

Figure 3.1 – Réduction HP p HC

La transformation f est évidemment polynomiale. Montrons que c’est une réduction, c’est-à-dire que
G admet une chaîne hamiltonienne si et seulement si f (G) possède un cycle hamiltonien.
Si G possède une chaîne hamiltonienne φ, alors le cycle xφx est hamiltonien dans f (G). Récipro-
quement, si f (G) admet un cycle hamiltonien, son sous-graphe privé de x, G, possède une chaîne
hamiltonienne.

33
3.3 Le problème SAT et le théorème de Levin-Cook

3.3 Le problème SAT et le théorème de Levin-Cook

Le problème de satisfabilité SAT est le premier problème qui a été montré NP-complet (théorème de
Cook en 1971). L’étude des variantes de ce problème permet d’une part d’introduire des techniques de
preuves et d’autre part de pointer sur la frontière entre problèmes faciles et difficiles.

3.3.1 Présentation du problème SAT

Le problème SAT est un problème de logique propositionnelle, encore appelée logique d’ordre 0 ou
logique des prédicats. Rappelons qu’un prédicat est défini sur un ensemble de variables logiques, à l’aide
des 3 opérations élémentaires que sont la négation NON (¬x que nous noterons aussi x̄), la conjonction
ET (x ∧ y) et la disjonction OU (x ∨ y). Un littéral est un prédicat formé d’une seule variable (x) ou de
sa négation x̄. Une clause est un prédicat particulier, formée uniquement de la disjonction de littéraux,
par exemple C = x ∨ ȳ ∨ z. Une formule est sous forme normale conjonctive si elle s’écrit comme la
conjonction de clauses. Le problème SAT consiste à décider si une formule en forme normale conjonctive
est satisfiable, c’est-à-dire si il existe une assignation τ de valeur de vérité (true, false) aux variables
telle que toutes les clauses sont true.

Définition SAT (Satisfiability)

Instance. m clauses Ci formées à l’aide de n variables logiques (littéraux).

Question. la formule Φ = C1 ∧ C2 ∧ · · · ∧ Cm est-elle satisfiable ?

Par exemple la formule (x ∨ ȳ ∨ z) ∧ (x̄ ∨ ȳ) ∧ (x ∨ z̄) est satisfaite avec l’assignation τ (x) = true et
τ (y) =false. Il est facile de se convaincre que le problème SAT est dans NP. Un certificat de positivité
consiste à donner une assignation des variables, codable sur un vecteur de n bits. La vérification que
toutes les clauses sont satisfaites est alors clairement polynomiale (plus précisément, dans O(nm)).
Cook a montré en 1971 que ce problème est NP-complet en codant l’exécution de tout algorithme
sur une machine de Turing non-déterministe par une expression en forme normale conjonctive.

3.3.2 Une première série de variante : k-SAT

On note k-SAT la variante du problème SAT où toutes les clauses ont exactement k littéraux (k ≥ 2).
La variante obtenue pour k = 3 est particulièrement utile, on peut établir le résultat simple suivant.

Définition

On dit qu’un problème π est NP-complet s’il est lui-même NP et que tout problème NP se réduit à π
en temps polynomial.

Theorème 3.3.1 (Levin-Cook). 3-SAT est NP-complet.

D’une manière générale, tous les problèmes k-SAT sont NP-complets pour k ≥ 3.
L’idée de la réduction à partir de SAT est simplement de réécrire chaque clause comme une clause de
cardinalité 3.

34
 Chapitre 3. La NP-Complétude

Exemple 3 ()
Transformer la clause de 5-SAT suivante en une formule de 3-SAT :
(x1 ∨ x2 ∨ x3 ∨ x4 ∨ x5 )
On ajoute une deux variables supplémentaires y1 et y2 et on scinde la caulse en 3. La clause
précédente peut s’écrire aussi :
(x1 ∨ x2 ∨ y1 ) ∧ (y¯1 ∨ x3 ∨ y2 ) ∧ (y¯2 ∨ x4 ∨ x5 )

Il est facile de vérifier que la donnée d’une fonction d’interprétation pour les variables booléennes
satisfait ou non la formule logique, donc SAT ∈ NP, il nous faut maintenant prouver que :

∀L ∈ NP, il existe une réduction polynomiale de L vers SAT.

La difficulté vient du fait qu’il faut prouver l’existence d’une réduction pour tous les langages L de
NP. La seule indication dont on dispose est l’existence d’une TM non déterministe qui accepte L en
temps polynomial.
Cook a montré dans la preuve de son théorème l’existence d’une transformation qui à chaque mot ω
et tout langage (problème) L ∈ NP associe une instance LSAT qui est positive si et seulement si ω ∈ L.

3.3.3 Variantes autour de 2-SAT

D’une certaine manière, k-SAT est un problème frontière,

Instance. m clauses Ci formées d’au plus deux littéraux à l’aide de n variables.

Question. la formule Φ = C1 ∧ C2 ∧ · · · ∧ Cm est-elle satisfiable ?

Theorème 3.3.2. 2-SAT est polynômial

3.4 NP-complétude

3.4.1 Ensemble complet

Un ensemble complet d’une classe d’ensembles est l’ensemble le « plus difficile »à décider parmi tous
les ensembles de la classe. Si on trouve un algorithme pour cet ensemble, alors on peut reconnaître tous
les autres ensembles de la classe.

Définition

Soit A une classe de problèmes. Un problème E est A-complet par rapport à une relation de réduction
 si
1. E ∈ A
2. ∀B ∈ A : B  E
Un problème E est A-difficile par rapport à une relation de réduction  si :
— ∀B ∈ A : B  E

35
3.4 NP-complétude

3.4.2 Propriété de la NP-complétude

Un problème E est NP-complet (par rapport à p ) si
— E ∈ NP
— ∀B ∈ NP :B p E
Un problème E est NP-difficile (par rapport à p ) si

∀B ∈ NP : B p E
Soit E un problème NP-complet, on’a alors :
— E ∈ P ssi P = NP ;
— E 6∈ P ssi P 6= NP ;
— Si E p B et B ∈ NP alors B est NP-complet.

Figure 3.2 – Classification des problèmes

Les Problèmes intrinsèquement complexes ont une complexité non polynomiale.

En pratique, beaucoup de problèmes intéressants s’avèrent être de complexité temporelle non déter-
ministe polynomiale.
Question fondamentale de la théorie de la complexité :
S’il existe un algorithme non déterministe polynomiale, existe-t-il alors un algorithme déterministe
polynomial résolvant ce même problème ?
Si un ensemble π appartient à NP, π appartient-il alors à P ?
autrement dit : P = NP ?
On sait que P ⊆ NP

Theorème 3.4.1. Si un problème de NP est résoluble en temps polynomial, alors P = NP.

De façon équivalente, si un problème quelconque de NP n’est pas résoluble en temps polynomial, alors
aucun problème NP-complet ne peut se résoudre en temps polynomial.

Comment démontrer
— NP ⊆ P
— ou non ( NP ⊆ P )
Prendre un élément E « représentatif »de NP (le plus difficile) et essayer de démontrer
— E∈P
— ou E 6∈ P

36
 Chapitre 3. La NP-Complétude

Choisir un élément E qui soit NP-complet par rapport à une relation de réduction p
— E ∈ NP
— ∀B ∈ NP : B p E
a. Montrer que E peut être décidé avec une TM détreministe en un temps polyômial (Écrire cet
algorithme).
b. ou bien, montrer que cet algorithme ne peut pas être décidé avec une TM déterministe en un
temps polynômial (donner une preuve formmelle).

3.4.3 Preuve de la NP-complétude

On peut prouver la NP-Complétude d’un problèmes par deux techniques :
— Réaliser une preuve semblable à celle pour SAT (approche difficile)
— Utiliser la propriété Si E p B avec E NP-complet et B ∈ NP alors B est NP-complet.

Theorème 3.4.2. Si π1 est un problème tel que π2 p π1 pour un certain problème π2 ∈ NPC, alors π1
est NP-difficile. De plus, si π1 ∈ NP, alors π1 ∈ NPC.

Figure 3.3 – Représentation visuelle des deux configurations possibles

3.4.4 Interpréter la NP-Complétude

Que signifie qu’un problème est NP-complet (sous l’hypothèse P 6= NP)
Le problème n’a pas de solution algorithmique polynomiale ;
Mais il s’agit de la complexité dans le pire des cas. Il est possible que la complexité soit polynomiale
pour la plupart des données

Comment résoudre un problème NP-complet ?

Changer le problème en un problème plus simple. Particulariser le problème pour certaines instances.

37
3.5 Autres problèmes NP-Complets

Utiliser un algorithme exponentiel si la plupart des instances à résoudre sont de complexité sur-
polynomiales
Utiliser la technique d’exploration, mais en se limitant à un nombre polynomial de cas (heuristique) :
Algorithme incomplet.
Si problème d’optimisation, calculer une solution approximative.

3.5 Autres problèmes NP-Complets

Nous donnons dans ce qui suit une série de réductions fondamentales vers des problèmes NP-complets
majeurs.

Problème du circuit hamiltonien HC

HC = ensemble des graphes possédant un circuit hamiltonien (circuit hamiltonien = circuit parcou-
rant une et une seule fois tous les sommets du graphe)
Le problème de la recherche d’un circuit eulerien est dans P.

Problème du voyageur de commerce TS

Étant donnés
— un graphe de n noeuds (villes) ;
— les distances associées à chaque arc (paires de villes) ;
— B : un entier positif,
Existe-t-il un circuit reliant les n noeuds (villes) et de longueur ≤ B ? On peut montrer que HC p
TS

Chemin le plus long entre deux sommets

Étant donnés
— un graphe où a et b sont parmi les nœuds ;
— les distances associées à chaque arc ;
— B :un entier positif.
Existe-t-il un chemin reliant a et b et de longueur ≥ B ?
Si on change « et de longueur ≤ B »alors le problème est dans P.

3-SAT

Problème de la satisfaisabilitè de formules de la forme

C1 ∧ C2 ∧ · · · ∧ Cn

avec
— Ci = Li1 ∨ Li2 ∨ Li3
— Li1 = Ak ou Li1 = ¬Ak
— Ak est une variable propositionnelle (forme normale conjonctive avec 3 variables par clause)

38
 Chapitre 3. La NP-Complétude

Couverture de sommets VC

Étant donnés
— un graphe
— B :un entier positif
Existe-t-il un sous-ensemble des sommets de taille ≤ B qui couvre tous les arcs du graphe (i.e. chaque
arc à au moins une extrémité dans ce sous-ensemble)
Le problème de la couverture des arcs est dans P

Problème de la clique

Étant donnés
— un graphe
— B :un entier positif
Existe-t-il un sous-ensemble des sommets de taille ≥ B qui soit une clique (i.e. chaque paire de
noeuds de ce sous-ensemble est reliée par un arc)

Nombre chromatique d’un graphe

Étant donnés
— un graphe
— B :un entier positif
Est-il possible de colorier les noeuds du graphe en utilisant au plus B couleurs, de telle sorte que
deux noeuds adjacents (i.e. reliés par un arc) soient de couleurs diffèrentes

Problème de partition

Étant donné un ensemble A et une taille s(a) pour chacun de ses éléments,
Existe-t-il un sous-ensemble B ⊆ A tel que
X X
s(a) = s(a)
a∈B a∈A\B

39
 Table des figures

1.1 Puissance de calcul du meilleur ordinateur mondial au fil des ans. . . . . . . . . . . . . 2

1.2 Les classes de complexité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.1 Une machine de Turing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

2.2 Équivalence entre un problème de décision et la reconnaissance d’un langage . . . . . . . 28
2.3 Discussion de la décidabilité des problèmes . . . . . . . . . . . . . . . . . . . . . . . . . 29

3.1 Réduction HP p HC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.2 Classification des problèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.3 Représentation visuelle des deux configurations possibles . . . . . . . . . . . . . . . . . . 37

41
TABLE DES FIGURES

42
 Liste des tableaux

1.1 Les classes de complexités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2.1 Exemple de machine de Turing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

2.2 Exemple d’exécution d’une machine de Turing . . . . . . . . . . . . . . . . . . . . . . . . 26

43
LISTE DES TABLEAUX

44
 Bibliographie

45