Chapitre 9(NP-complétude, Cormen chap 36)

Tout au long de ce cours, nous nous sommes intéressés à l’algorithmique

c’est-à-dire la conception et l’analyse d’algorithmes pouvant résoudre
certains problèmes. Une question se pose : Pouvons-nous associer à un
problème une certaine mesure qui nous renseignerait sur sa «difficulté
de résolution» ? Cette mesure serait en quelque sorte une borne inférieure
pour tout algorithme (connu ou non) résolvant ce problème. C’est la théorie
de la complexité qui s’intéresse à cette question.

En utilisant l’algorithmique et en analysant explicitement un algorithme

donné, nous pouvons montrer que le problème peut être résolu en
O( f (n)) pour une fonction f (n) que nous espérons «réduire» le plus possible.
En utilisant la complexité, nous voulons plutôt trouver une fonction g (n) , la
plus «grande» possible telle que nous puissions prouver que tout algorithme
qui résout le problème le fait en Ω( g (n)) . Une telle fonction g (n) est appelée
une borne inférieure à la complexité du problème. Évidemment, notre but
est que f (n) = θ ( g (n)) car ainsi nous sommes assurés d’avoir l’algorithme le
plus efficace possible (à une constante près) pour résoudre notre problème.
Malheureusement, cela ne se produit que très rarement. Tout au long du
cours, c’est la complexité temporelle qui nous a intéressée et c’est elle qui
continuera à le faire. De façon générale on peut s’intéresser à d’autres
complexités (spatiale par exemple). Ainsi, ayant défini une mesure de
complexité (le temps dans notre cas) cette mesure peut nous servir à
regrouper en «classes» différents problèmes (par rapport à cette mesure).
Dans ce bref chapitre, nous allons nous intéresser aux classes P et NP (sont-
elles différentes ? Personne ne le sait !).

Tous les algorithmes étudiés jusqu’à présent étaient des algorithmes en

temps polynomial : sur des entrées de taille n, leur temps d’exécution dans le
pire cas est en O(n k ) pour une certaine constante k. Il est naturel de se
demander si tous les problèmes peuvent être résolus en temps
polynomial. La réponse est non.

De manière générale, on considère que les problèmes résolubles par des

algorithmes en temps polynomial sont traitables, et que les problèmes
nécessitant un temps superpolynomial sont intraitables. Ce chapitre aborde

1
une classe de problèmes intéressante, appelée problèmes «NP-
complets»(NPC) dont le statut est inconnu. Aucun algorithme en temps
polynomial n’a encore été découvert pour un problème NPC, et personne n’a
été capable d’établir une borne inférieure superpolynomiale pour aucun
d’entre eux. La plupart des théoriciens de l’informatique pensent que les
problèmes NPC sont intraitables. En effet, si l’un des problèmes NPC
pouvait être résolu en temps polynomial, alors tous les problèmes NPC (et
même ceux de NP) auraient un algorithme permettant de les résoudre en
temps polynomial (vous verrons pourquoi).

Pour devenir un bon concepteur d’algorithmes, il faut

comprendre les rudiments de la théorie de la NP-complétude.
Si l’on peut établir qu’un problème est NP-complet, on peut
être quasi certain qu’il est intraitable. En tant qu’analyste,
vous perdrez alors moins de temps en développant un
algorithme d’approximation plutôt que de chercher un
algorithme rapide capable de résoudre le problème avec
exactitude.

Par ailleurs, de nombreux problèmes naturels et intéressants qui ne semblent

pas a priori plus difficiles que le tri, la recherche dans un graphe, ou les flux
de réseau, sont en réalité NPC. Il est donc important d’être familiarisé avec
cette classe de problèmes remarquables.

Notre but n’est pas de prouver l’ensemble des résultats que nous
présenterons mais plutôt de donner à l’étudiant une idée générale de la NP-
complétude de même que ses répercussions dans la conception
d’algorithmes (plusieurs preuves seront demandées en exercices).

2
 PROBLÈMES ABSTRAITS

Un problème abstrait Q est une relation binaire sur un ensemble I

d’instances d’un problème et un ensemble S de solutions d’un problème.

Exemple :

Considérons le problème PLUS-COURT-CHEMIN (PCC) consistant à

trouver un plus court chemin entre deux sommets d’un graphe non orienté et
non pondéré G=(S,A). Une instance de PCC est un triplet composé d’un
graphe et de deux sommets. Une solution est une séquence de sommets du
graphe; si cette séquence est vide, il n’existe aucun chemin dans le graphe
entre ces sommets. PCC est alors la relation PCC : I → S qui associe chaque
instance à un plus court chemin (pas nécessairement unique) reliant les deux
sommets dans le graphe.

Cette formulation d’un problème abstrait est trop générale pour notre propos.
Pour des raisons de simplicité, la théorie de la NP-complétude est restreinte
aux problèmes de décisions : la solution est oui/non.

Dans ce cas, on peut voir un problème de décision abstrait comme une

fonction qui fait correspondre l’ensemble des instances I à l’ensemble des
solutions {0, 1}.

De nombreux problèmes abstraits ne sont pas des problèmes de décision,

mais des problèmes d’optimisation, dans lesquels une certaine valeur doit
être minimisée ou maximisée. Pour appliquer la théorie de la NP-complétude
aux problèmes d’optimisation, il faut les reformuler pour en faire des
problèmes de décision. Le plus souvent, un problème d’optimisation peut
être reformulé en lui imposant une borne sur la valeur à optimiser

3
Exemple :

Un problème de décision CHEMIN en relation avec le problème PCC est :

«Étant donné un graphe G=(S,A), deux sommets u, v ∈ S, et un entier positif
ou nul k, existe-t-il un chemin dans G entre u et v dont la longueur est au
plus égale à k ?» Ainsi, si i = < G,u,v,k >, alors CHEMIN(i)=1 si un tel
chemin existe.

Enfin, si l’on peut convaincre qu’un problème de décision est

difficile, on convainc du même coup de la difficulté du
problème d’optimisation associé. Donc, bien qu’elle restreigne
son champ d’observation aux problèmes de décision, la théorie
de la NP-complétude s’applique à un domaine beaucoup plus
large.

4
 CODAGE

Si un programme informatique doit résoudre un problème abstrait, les

instances du problème doivent être représentées sous une forme
compréhensible par le programme.
Un codage d’un ensemble S d’objets abstraits est une application e de S vers
l’ensemble des chaînes binaires.

Exemple :

e(17) = 10001

Donc, un algorithme informatique qui résout un certain problème de

décision prend en fait en entrée un codage d’une instance du problème. Un
problème dont les instances forment l’ensemble des chaînes binaires est
appelé problème concret. On dit alors 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 O(n k ) pour une certaine constante k.

Classe de complexité P

La classe de complexité P est l’ensemble des problèmes concrets de

décision qui sont résolubles en temps polynomial.

Étant donné un problème de décision abstrait Q reliant un ensemble

d’instances I à {0,1}, un codage e : I → {0,1}* peut servir à déduire le
problème de décision concret correspondant, que nous noterons e(Q).

On souhaite étendre la définition de «résoluble en temps polynomial» des

problèmes concrets aux problèmes abstraits en utilisant les codages comme
pont, mais on voudrait que la définition soit indépendante de tout codage
particulier. Autrement dit, l’efficacité de résolution d’un problème ne devra
pas dépendre de la façon dont le problème est codé. Malheureusement, elle
est très dépendante.

5
Exemple :

On suppose qu’un entier k doit être fourni comme entrée unique d’un
algorithme, et que le temps d’exécution de l’algorithme est θ (k ) . Si l’entier k
est fourni en unaire (une chaîne de k 1) le temps d’exécution est en O(n) sur
des entrées de longueur n, c’est-à-dire polynomial. En revanche, si l’on
utilise la représentation binaire plus naturelle de l’entier k, la longueur de
l’entrée est n = lg k  + 1 . Dans ce cas, le temps d’exécution de l’algorithme
est θ (k ) = θ (2 n ) , qui est exponentiel par rapport à la taille de l’entrée. Donc,
selon le codage choisi, l’algorithme peut s’exécuter en temps polynomial ou
superpolynomial.

Le codage d’un problème abstrait est donc très important pour une bonne
compréhension du temps polynomial. On ne peut pas vraiment parler de
résolution d’un problème abstrait sans commencer par spécifier le codage.
Néanmoins, si l’on met de côté les codages «coûteux» comme les codages
unaires, le codage d’un problème intervient peu sur la question de savoir si
la résolution peut s’effectuer en temps polynomial.

Définitions :

On dit qu’une fonction f : {0,1}* → {0,1}* est calculable en temps polynomial

s’il existe un algorithme polynomial A qui, étant donnée une entrée
x ∈ {0,1} quelconque, produit le résultat f(x). Pour un ensemble I d’instances
*

d’un problème, on dit que deux codages e1 et e2 sont reliés

polynomialement s’il existe deux fonctions calculables en temps
polynomial f12 et f21 telles que pour tout i ∈ I , on a f12 (e1 (i)) = e2 (i) et
f 21 (e2 (i )) = e1 (i ) .

Théorème :

Soit Q un problème de décision abstrait sur un ensemble d’instances I, et

soient e1 et e2 des codages reliés polynomialement sur I. Alors,
e1 (Q) ∈ P ⇔ e2 (Q) ∈ P .

6
 UN CADRE POUR LES LANGAGES FORMELS

L’un des intérêts pratiques de s’en tenir aux problèmes de décision est qu’ils
rendent facile à utiliser les mécanismes de la théorie des langages formels
(voir le cours informatique théorique). Il n’est pas inutile de revoir quelques
définitions ce cette théorie.

Définitions :
- Un alphabet Σ est un ensemble fini de symboles.
- Un langage L sur Σ est un ensemble quelconque de chaînes
construites à partir de Σ.
- La chaîne vide est notée ε (parfois λ).
- Le langage vide est noté ∅.
- Le langage de toutes les chaînes sur Σ est noté Σ*.
- Opérations sur les langages : union, intersection, complément,
fermeture, concaténation etc.
Note : la longueur d’une chaîne est toujours finie

Du point de vue de la théorie des langages, l’ensemble des instances d’un

problème de décision Q quelconque est simplement Σ*, où Σ={0,1}. Puisque
Q est entièrement caractérisé par les instances du problème qui produisent
une réponse 1 (oui), on peut voir Q comme un langage L sur Σ={0,1}, où
L = {x ∈ ∑ * : Q( x) = 1}.

Le cadre du langage formel nous permet d’exprimer de façon concise la

relation entre les problèmes de décision et les algorithmes qui les résolvent.

On dit qu’un algorithme A accepte une chaîne x∈{0,1}* si, étant donnée une
entrée x, l’algorithme sort A(x)=1. Le langage accepté par un algorithme A
est alors L = {x ∈ {0,1}* : A( x) = 1}. Un algorithme A rejette une chaîne x si
A(x)=0.

7
Un langage L est décidé par un algorithme A si toute chaîne binaire de L est
acceptée par A et si toute chaîne binaire n’appartenant pas à L est rejetée par
A.

Les notions de langages acceptés et décidés polynomialement se déduisent

immédiatement.

Important
Pour accepter un langage, un algorithme n’a besoin de s’intéresser qu’aux
chaînes de L, alors que pour décider un langage, il doit correctement
accepter ou rejeter toutes les chaînes de {0,1}*.

Ainsi, nous pouvons alors définir informellement une classe de complexité

comme un ensemble de langages, dont l’appartenance est déterminée par une
mesure de la complexité (comme le temps d’exécution) d’un algorithme
qui détermine si une chaîne donnée x appartient au langage L (la véritable
définition est un peu plus technique!).

En utilisant ce cadre de la théorie des langages, on peut proposer une autre

définition de la classe de complexité P :

P = { L ⊆ {0,1}* : ∃ un algorithme A qui décide L en temps polynomial }

Nous avons aussi le théorème suivant :

Théorème :
P = { L : L est accepté par un algorithme polynomial }

8
 VALIDATION EN TEMPS POLYNOMIAL

Nous nous intéressons maintenant aux algorithmes qui «valident»

l’appartenance à un langage.

Exemple :
Soit i = <G, u, v, k > une instance du problème de décision CHEMIN. On se
donne aussi un chemin p de u vers v. On peut facilement vérifier que la
longueur de p est au plus égale à k, et si oui, on peut voir p comme un
«certificat» de l’appartenance effective de i à CHEMIN.

Définition :
Un algorithme de validation A est un algorithme à deux arguments, où un
argument est une chaîne d’entrée ordinaire x et l’autre une chaîne binaire y
appelée certificat. Un algorithme A à deux arguments valide une chaîne
d’entrée x s’il existe un certificat y tel que A(x,y)=1. Le langage validé par
un algorithme de validation A est :
L = { x ∈ {0,1}* : il existe y ∈{0,1}* tel que A(x, y) = 1 }.

Intuitivement, un algorithme A valide un langage L si pour toute chaîne x ∈

L, il existe un certificat que A peut utiliser pour démontrer que x ∈ L. Par
ailleurs, pour toute chaîne x ∉ L, il ne doit pas exister de certificat prouvant
que x ∈ L.

La classe de complexité NP est la classe des langages pouvant être validés

par un algorithme polynomial. Plus précisément, un langage L appartient à
NP si et seulement si il existe un algorithme polynomial A à deux entrées et
une constante c telle que

L={ x ∈{0,1}* : il existe un certificat y avec |y|=O(|x|c) tel que A(x, y)=1 }.

On dit que l’algorithme A valide le langage L en temps polynomial.

9
Ainsi, si L ∈ P, alors L ∈ NP, puisque s’il existe un algorithme polynomial
décidant L, ce même algorithme peut être facilement converti en un
algorithme de validation à deux arguments qui se contente d’ignorer le
certificat et accepte exactement les chaînes d’entrée dont il détermine
qu’elles appartiennent à L. Donc,

P ⊆ NP

Une question naturelle se pose :

P = NP ?
On ne le sait pas !. La plupart des chercheurs pensent que
non.

P ≠ NP est une conjecture .

Intuitivement, la classe P est composée de problèmes qui

peuvent être résolus rapidement. La classe NP est composée de
problèmes pour lesquels une solution peut être validée
rapidement. En général, nous observons qu’il est plus difficile
de résoudre un problème à partir de zéro que de valider une
solution clairement présentée. Les théoriciens de
l’informatique pensent en général que cette analogie s’étend
aux classes P et NP, et donc que NP inclut des langages qui ne
sont pas dans P.

10
 NP-COMPLÉTUDE ET RÉDUCTIBILITÉ

La raison qui pousse le plus les théoriciens de l’informatique à croire que

P≠NP est sans doute l’existence de la classe des problèmes NP-complets
(NPC).

Propriété fondamentale de cette classe :

Si un seul problème NP-complet peut être résolu en temps polynomial,

alors tous les problèmes de NP peuvent être résolus en temps
polynomial, autrement dit, P = NP.

Malgré des années de recherche…..aucun algorithme polynomial n’a jamais

été découvert pour aucun problème NP-complet. Les langages NP-complets
sont, dans un sens, les langages les plus «difficiles» de NP. La notion qui
permet de comparer la «difficulté» relative des langages est «la réductibilité
en temps polynomial».

Définition :

On dit qu’un langage L1 est réductible en temps polynomial à un langage

L2, noté L1 ≤p L2, s’il existe une fonction calculable en temps polynomial
f : {0,1} → {0,1} telle que pour tout x ∈ {0,1} ,
* * *

x ∈ L1 ⇔ f(x) ∈ L2.

Les réductions en temps polynomial nous donnent un outil puissant pour

démontrer que différents langages appartiennent à P.

Théorème:

Si L1, L2 ⊆ {0,1}* sont des langages tels que L1 ≤p L2, alors :

L2 ∈ P ⇒ L1 ∈ P.

11
NP-complétude

Les réductions en temps polynomial fournissent un moyen formel de

montrer qu’un problème est au moins aussi difficile qu’un autre, à un facteur
près.
On peut à présent définir l’ensemble des langages NP-complets, qui sont les
problèmes les plus «difficiles» de NP.

Définition :
Un langage L ⊆ {0,1}* est NP-complet si
(*) L ∈ NP, et
(**) L* ≤p L pour tout L* ∈ NP.

Un langage L ⊆ {0,1}* est NP-difficile s’il vérifie (**) mais pas

nécessairement (*).

Comme le montre le théorème suivant, la NP-complétude est une notion

cruciale pour la question de savoir si P = NP.

Théorème :
Si un problème NP-complet 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 de NP-complet ne peut se
résoudre en temps polynomial.

Ainsi, on comprend maintenant que montrer qu’un problème est NP-complet

donne un excellent indice de son intraitabilité.

Le théorème suivant constitue la fondation de la plupart des méthodes de

démonstration qu’un langage est NP-complet.

12
Théorème :
Si L est un langage tel que L* ≤p L pour un certain L* ∈ NPC, alors L est
NP-difficile. De plus, si L ∈ NP, alors L ∈ NPC.

Les démonstrations que certains problèmes (langages) sont NP-complets

dépassent le cadre du cours. Cependant nous exposons ici les principaux
problèmes NP-complets que l’analyste informatique se doit de connaître afin
de ne pas «gaspiller son énergie à chercher des algorithmes efficaces pour
ces problèmes mais plutôt s’orienter vers des solutions approchées».

1- Le problème de la satisfaisabilité d’un circuit est NP-complet.

2- La satisfaisabilité d’une formule booléenne est un problème NP-
complet.
3- La satisfaisabilité des formules booléennes sous leur forme normale
conjonctive d’ordre 3 est NP-complet.
4- Le problème de la clique est NP-complet.
5- Le problème de la couverture des sommets est NP-complet.
6- Le problème de la somme d’un sous-ensemble est NP-complet.
7- Le problème du cycle hamiltonien est NP-complet.
8- Le problème du voyageur de commerce est NP-complet.

Circuit SAT

SAT

3 FNC SAT

CLIQUE CYCLE HAM

VERTEX C. TSP

SSET SUM

13
De nombreux problèmes d’intérêt pratique sont NP-complets,
mais trop importants pour qu’on les laisse tomber, simplement
parce qu’une solution optimale est intraitable. Si un problème
est NP-complet, il y a peu de chances de trouver un algorithme
polynomial capable de le résoudre exactement mais cela
n’implique pas que tout espoir soit perdu. Il existe deux
approche pour contourner la NP-complétude. D’abord, si les
entrées réelles son petites, un algorithme exponentiel peut
parfaitement convenir. Ensuite, il est encore possible de
trouver des solutions presque optimales en temps polynomial.
En pratique on peut souvent se contenter d’une quasi-
optimalité. Un algorithme qui retourne des solutions presque
optimales est appelé algorithme d’approximation. L’étude de
tels algorithmes est cruciale et ferait l’objet du cours «analyse
d’algorithmes II». Nous désirons cependant terminer ce cours
en présentant un tel algorithme pour un problème bien connu
soit le problème du sac à dos sans fractionnement.

14
Un algorithme d’approximation pour le problème du sac à dos (13.2.2).

- Problème du sac à dos avec n objets sans fractionnement (section 8.4)

- Cette version est NP-difficile
- Programmation dynamique, θ (nW ) (section 8.4)
- Si fractionnement, O (n log n) (section 6.5)
- Idée : Utiliser l’approche vorace afin d’obtenir une solution sous-optimale à une
constante près.
- Soit opt la solution optimale et soit opt* la solution retournée par approx-knap.
- Sans perte de généralité
o Aucun wi n’est plus grand que W.
o La somme des wi est strictement plus grande que W.
l
- Soit l le plus petit entier tel que ∑w 1
i >W .
l
- Soit opt** la solution du problème où W = W * = ∑ wi .
1
Fonction greedy-knap(w[1..n],v[1..n],W)
Sort the instance in decreasing order of v[i]/w[i]
weight, value = 0
for i = 1 to n do
if weight + w[i] ≤ W then
value = value + v[i]
weight = weight + w[i]
return value

Fonction approx-knap(w[1..n],v[1..n],W)
biggest = max(v[i])
return max(biggest,greedy-knap(w,v,W))

Ainsi, on remarque que greedy-knap est arbitrairement mauvais. Il suffit de

considérer w1 = 1, v1 = 2, w2 = x, v 2 = x,W = x .
Pour approx-knap, nous avons :

Opt* = max( biggest, greedy-knap(w,v,W))

≥ (biggest + greeady-knap(w,v,W))/2
 l −1
 l
 vl + ∑ vi  ∑v i
≥  =
i =1 opt * *
i =1
=
2 2 2
opt
≥ .
2
D’où le résultat.

15
QUELQUES DÉFINITIONS DE PROBLÈMES NP-COMPLETS

1- Le problème de la satisfaisabilité d’un circuit (CIRCUIT-SAT).

Étant donné un circuit combinatoire booléen composé de portes ET, OU, et NON,
est-il satisfaisable ?

2- La satisfaisabilité d’une formule booléenne (SAT).

Une formule booléenne donnée est-elle satisfaisable ?

3- La satisfaisabilité des formules booléennes sous leur forme

normale conjonctive d’ordre 3 (3 FNC SAT).
Une formule booléenne exprimée comme un ET de clauses, chacune d’elles étant
le OU de 3 littéraux est-elle satisfaisable ?

4- Le problème de la clique (CLIQUE).

Trouver, dans un graphe non orienté G = ( S, A), un sous-ensemble S* ⊆ S de
taille maximal dont chaque paire de sommets est reliée par une arête dans A.

5- Le problème de la couverture des sommets (VERTEX COVER).

Trouver, dans un graphe non orienté G = ( S, A), un sous-ensemble S* ⊆ S de
taille minimal tel que si {u,v} ∈ A, alors u ∈ S* ou v ∈ S* (ou les deux).

6- Le problème de la somme d’un sous-ensemble (SUBSET SUM).

On se donne un ensemble fini E ⊂ ℵ et une valeur cible t ∈ ℵ. On veut savoir s’il
existe un sous-ensemble E* ⊆ E dont les éléments ont pour somme t.

7- Le problème du cycle hamiltonien (CYCLE-HAM).

Le graphe non orienté G=( S, A) possède-t-il un cycle hamiltonien ?

8- Le problème du voyageur de commerce (TSP).

Un voyageur de commerce doit visiter n villes. Il souhaite faire une tournée en
visitant chaque ville exactement une fois et revenir à son point de départ. Il
souhaite aussi parcourir une distance totale minimale.

16