Mario MarchandIFT-17588 (Automne 2005)1 Conception et analyse dalgorithme Cours sur Elluminate : Mardi 13h30 à 15h, mercredi 14h à 15h30 Atelier sur Elluminate

Mario Marchand IFT-17588 (Automne 2005) 1

Conception et analyse d’algorithme

Cours sur Elluminate : Mardi 13h30 à 15h, mercredi 14h à 15h30 Atelier sur Elluminate : Vendredi 8h30 à 10h30 Disponibilité de l'enseignant : par courriel en tout tempsSite Web : http://cours.ift.ulaval.ca/2010h/ift3001_12992/

Mario Marchand IFT-17588 (Automne 2005) 2

Chapitre 9

L’approche gloutonne (vorace)

Suite et fin…

Un algorithme glouton construit une solution en effectuant une séquence de décisions. Pour chaque décision:

Le choix effectué satisfait les contraintes du problèmeLe choix effectué est localement optimalLe choix effectué est irrévocable

C’est une bonne stratégie lorsque la séquence de décisions, localement

optimales, donne une solution globalement optimale ou lorsque l’on est

satisfait de la « non optimalité » de la solution globale

Mario Marchand IFT-17588 (A-05), Chapitre 9 3

Algorithme de Prim

Arbre de recouvrement minimal (ARM) d’un graphe connexe non orienté est un arbre

de recouvrement dont la somme des poids de chacune de ses arêtes est minimale

Algorithme de Prim On débute avec un arbre constitué d’un seul nœud Un ARM est construit en ajoutant un nœud à la fois à cet arbreÀ chaque étape, le nœud est choisi de

manière gloutonne

C’est le nœud, n’appartenant pas

à l’arbre, qui est connecté à un nœud

de l’arbre par l’arête de poids minimal


Algorithme de Prim (suite)

L’algorithme termine lorsque l’arbre

contient les n nœuds du grapheL’algorithme effectue donc n – 1 choix gloutons

L’algorithme retourne l’ensemble des arêtes constituant cet arbre de recouvrement


Exactitude de l’algorithme de Prim

Soit T0 l’arbre initial contenant un seul nœud et Ti l’arbre à la fin de la i-ième étape gloutonne de l’algorithme de Prim (contenant i + 1 nœuds). Tn-1 est alors l’arbre final fourni par l’algorithme de PrimDémontrons, par induction, que chaque arbre Ti est un sous arbre d’un ARM

Si c’est vrai, alors Tn-1 est un ARMT0 est forcément un sous arbre d’un ARMDémontrons par contradiction que pour tout i : si Ti-1 est un sous arbre d’un ARM, alors il en sera ainsi pour Ti


Exactitude de l’algorithme de Prim

Supposons que Ti ne soit pas un sous arbre d’un ARM mais

Par contre, Ti-1 est, par hypothèse, un sous arbre d’un arbre de recouvrement minimal T

Soit ei = (v,u) = l’arête de poids minimal utilisé par l’algorithme de Prim pour passer de Ti-1 à Ti

Par hypothèse, ei ne peut pas être inclus dans T car sinon Ti serait un sous arbre d'un arbre de recouvrement minimal.

L’ajout de ei à T forme forcément un cycle contenant ei ainsi qu’une autre arête (v’,u’) telle que v’ 2 Ti-1 et u’Ti-1

En enlevant (v’,u’) nous obtenons un autre ARM T’ T qui inclut ei et dont le poids total est inférieur ou égal à celui de T car le poids de ei est inférieur ou égal à celui de (v’,u’).

Donc T’ est forcément un ARM. Alors Ti est un sous arbre d’un

ARM. CQFD


Analyse de l’efficacité de l’algorithme de Prim

Le temps d’exécution de l’algorithme de Prim dépend de la structure de données utilisée pour la file d’attente des nœuds 2 V – VT

Utilisons un tas-min pour la file d’attente des nœuds 2 V – VT

Le nœud u* 2 V – VT ayant la plus faible valeur wu* sera donc toujours au sommet du tas-min et cela prendra un temps 2 O(log(|V – VT|)) pour reconstruire le tas-min après avoir enlevé u*

Lorsque l’on ajoute un nœud u* à l’arbre, il faut, pour chaque u 2 V – VT connecté à u*, mettre possiblement à jour wu et vu et reconstruire le tas-min pour chaque u mis à jour

Si Eu* désigne l’ensemble des nœuds connectés à u*, cela nécessite un temps

2 O(|Eu*|£log(|V – VT|)) 2 O(|Eu*|£log(|V|)) pour les mis à jour des u 2V –

VT connectés à u*

Le temps total requis pour les mis à jours effectuées pour tous les nœuds u* insérés dans l’arbre sera de O(|E|£log(|V|)) pour un graphe de |E| arêtes

La somme des temps requis pour enlever chacun des |V| - 1 nœuds u* du tas min sera de O((|V|-1)£log(|V|))

Le temps d’exécution total sera donc en O(|E|£log(|V|)) puisque |E| ¸ |V|-1 pour un graphe connexe


Algorithme de Kruskal


Algorithme de Kruskal (suite)


L’algorithme de Kruskal

L’algorithme trie d’abord, en ordre croissant de leur poids, l’ensemble E des arêtes d’un graphe G = hV,Ei connexe

Ensuite, en débutant avec ET = ;, l’algorithme ajoute à ET l’arête e 2 E de poids we minimal qui ne forme pas de cycle avec les arêtes déjà dans ET

Cette arête n’est pas nécessairement connectée à une autre arête de ET

L’ensemble des arêtes de ET constitue alors une forêt (d’arbres)

Cette séquence de choix gloutons se termine lorsque |ET| = |V| – 1

ET deviens alors un arbre (unique) qui recouvre G


Analyse de l’efficacité de l’algorithme de Kruskal

Le tri de E nécessite un temps 2 (|E| log |E|) Pour chacun des choix gloutons, nous devons:

Choisir le prochain élément e de E (en un temps (1)) Vérifier si e forme un cycle avec un arbre de la forêt Fi-1

Pour cela, il faut vérifier si ei = (v,u) est tel que v et u appartiennent au même arbre dans Fi-1 (voir figure)

Si e ne forme pas de cycle: ajouter ei à Fi-1 pour obtenir Fi


Analyse de l’efficacité de l’algorithme de Kruskal (suite)

Les arbres de la forêt Fi-1 forment une collection d’ensembles disjoints: chaque nœud dans Fi-1 est élément d’un seul arbre

Initialement, nous avons |V| ensembles disjoints S1, S2, … S|V| où chaque ensemble Si contient un seul nœud de V

Ayant choisi l’arête (v,u) de poids minimal, il faut trouver l’ensemble Si contenant v et l’ensemble Sj contenant u.

On ignore (v,u) et on passe à l’arête suivante si Si = Sj

Si non, on fusionne Si avec Sj pour obtenir Si [ Sj L’algorithme de Kruskal effectue (exactement) |V| – 1 opérations fusionner

car nous avons 1 fusion par arête de l’arbre de recouvrement minimal L’algorithme de Kruskal effectue au plus 2£|E| opérations trouver

car, en pire cas, toutes les arête de E seront examinées. Nous verrons que le total de ces opération trouver et fusionner nécessite un

temps O(|V| log |V| + |E|) ou de O(|V| + |E| log |V|) Le temps d’exécution total de l’algorithme de Kruskal sera alors dominé par

l’étape du triage de E. Le temps total d’exécution sera alors 2 O(|E| log |E|).


Structures de données pour ensembles disjoints

Nous avons un ensemble S de n éléments qui sont distribués, initialement, parmi des ensembles disjoints S1, S2, … Sn où chaque Si contient initialement un seul élément. Nous effectuerons alors n – 1 opérations fusionner

Exemple. Soit S = {1,2,3,4,5,6}. Initialement nous avons les ensembles disjoints:

{1}, {2}, {3}, {4}, {5}, {6} Après les opérations fusionner(1,4) et fusionner(5,2), nous avons:

{1,4}, {5,2}, {3}, {6} Après les opérations fusionner(4,5) et fusionner(3,6), nous avons:

{1,4,5,2}, {3,6} Chaque ensemble sera identifié par un seul de ses éléments, appelé le

représentant (de l’ensemble) Le choix du représentant sera arbitraire

Il existe deux principales structures pour ensembles disjoints: La structure trouver-rapide qui optimise l’opération trouver La structure fusionner-rapide qui optimise l’opération fusionner


La structure trouver-rapide

Maintenons un tableau R[1..n] tel que R[i] est le représentant de l’ensemble auquel appartient l’élément i.

Par exemple, pour les ensembles:

{1,4,5,2}, {3,6} nous avons:

R[1] = 1 R[2] = 1 R[3] = 3 R[4] = 1 R[5] = 1 R[6] = 3

Chaque opération trouver(i) s’effectue en temps (1) car il suffit d’effectuer la référence R[i]

Pour m opérations trouver nécessitent donc un temps (m)


La structure trouver-rapide (suite)

De plus, chaque ensemble est représenté par une liste de pointeurs. Chaque liste contient une en-tête incluant le nombre d’éléments dans l’ensemble

Tableau R[1..n]


La structure trouver-rapide (suite)

Le temps requis pour effectuer n – 1 opérations fusionner est donné par le nombre total de mis à jour des éléments du tableau R[1..n]

Considérons un élément i quelconque. Initialement i est seul dans son ensemble SR[i]

Soit Ai le nombre de fois que le représentant R[i] sera mis à jour

R[i] est (possiblement) mis à jour seulement si SR[i] est fusionné avec un SR[j] tel que |SR[j]| ¸ |SR[i]|

La cardinalité de SR[i] augmentera donc au moins d’un facteur deux lors de chaque mis à jour de R[i]

Initialement |SR[i]| = 1 et, en tout temps, |SR[i]| · n. Le nombre Ai de mise à jour doit donc satisfaire 2Ai · n. Alors Ai · lg(n).

Le nombre total de mis à jour des éléments de R[1..n] est · n lg(n) Le temps requis pour effectuer n – 1 opérations fusionner O(n log n)

Conclusion pour la structure trouver-rapide: L’algorithme de Kruskal nécessite |V| – 1 opérations fusionner et au plus

2£|E| opérations trouver. L’algorithme de Kruskal est en O(|V| log |V| + |E|) si on utilise la structure

trouver-rapide pour représenter les forêts Fi générées par l’algorithme.


La structure fusionner-rapide

La structure du tableau R[1..n] est celle d’une forêt: chaque représentant d’ensemble est le nœud d’un arbre et R[i] désigne le parent de i (et non le représentant)

Exemple: lorsque R[1..6] = 1, 5, 3, 1, 1, 3

Chaque opération fusion: (1) mettre à jour une seule valeur de R[i] Nous effectuons R[3] Ã 1


La structure fusionner-rapide (suite)

trouver(i) pourrait nécessiter un temps (n) lorsque i est situé au niveau inférieur d’un arbre de profondeur n.

Il faut donc éviter, le plus possible, de construite des arbres profonds. Pour tenter d’arriver à cette fin, connectons la racine de l’arbre le moins

profond (à celui de l’arbre le plus profond) lors de chaque opération fusionner.

Théorème: En utilisant cette technique pour fusionner deux ensembles, après une séquence arbitraire d’opérations fusionner, tout arbre contenant k nœuds aura une hauteur d’au plus blg(k)c

Ainsi m opérations trouver s’effectuent en temps O(m log n) Conclusion pour la structure fusionner-rapide:

Le temps requis pour effectuer n – 1 opérations fusionner et m opérations trouver est en O(m log n + n)

L’algorithme de Kruskal nécessite |V| – 1 opérations fusionner et au plus 2£|

E| opérations trouver. Le temps requis pour ces opérations est en O(|E| log |V| + |V|) si l’on

utilise la structure fusionner-rapide pour représenter les forêts Fi générées par l’algorithme de Kruskal.

Mario Marchand IFT-17588 (Hiver 2005) 19

Chapitre 10

Les limites de la puissance algorithmique

Après l’étude de la conception et l’analyse d’algorithmes, nous allons maintenant aborder la complexité du calcul :

l’étude des limites de ce que les algorithmes peuvent accomplir!

Mario Marchand IFT-17588 (H-05), Chapitre 10 20

Plan

Complexité des problèmes et les minorants Algorithmes à temps polynomial Problèmes de décision Classe P L’indécidabilité Systèmes de preuves vérifiables (en un temps plynomial) Polynomialement Turing-Réductible (PTR) Classes NP-difficile et NP-complet


Introduction Question: Combien d’opération élémentaires en pire cas un algorithme doit–

il effectuer pour résoudre notre problème? Exemple: combien de comparaisons, en pire cas, n’importe quel algorithme

de tri doit-il effectuer pour trier un tableau? On cherche alors une borne asymptotique inférieure (minorant) sur le temps

d’exécution que doit avoir, en pire cas, n’importe quel algorithme pour résoudre un problème donné

On cherche donc la fonction g(n) telle que Cworst(n) 2 (g(n)) pour tous les algorithmes possibles (on prend la meilleure borne)

Exemple: un algorithme de tri par comparaisons, quel qu’il soit, doit effectuer (n log n) comparaisons, en pire cas.

Un algorithme est dit asymptotiquement optimal lorsque son temps d’exécution en pire cas 2 O(g(n))

Lorsque la complexité de l’algorithme coïncide avec celui du problème. La complexité d’un problème est la complexité du meilleur algorithme

pour le résoudre dans le pire cas.

La complexité d’un problème nous informe

sur le degré d’optimalité d’un algorithme


Minorants triviaux

Un minorant trivial est une borne inférieure obtenue en examinant uniquement la taille de la réponse que doit fournir l’algorithme et la quantité d’éléments d’entrée que l’algorithme doit examiner.

Ex1: tout algorithme devant générer toutes les permutations de n objets s’exécute en temps 2 (n!) car les n! permutations possibles doivent être produites.

Ex2: il est de (n2) pour le problème du commis voyageur car nous devons examiner les n(n-1)/2 distances entre les n villes. Mais nous ne connaissons présentement aucun algorithme à temps polynomial en n.

Ex3: Multiplication de 2 matrices Calcul direct: n3

Algorithme de Strassen (1969): n2.81

Meilleur algorithme connu (Coppersmith-Winograd, 1987): n2.376

Il existe une borne inférieure pour ce problème: n2, l'algorithme doit au moins lire les n2 entrées de chaque matrice.


Minorants informationnels

Minorants obtenus en considérant la quantité d’information qu’un algorithme doit extraire pour résoudre un problème.

Ex: trouver un nombre entre 1 et n en posant le minimum de questions. La meilleure stratégie consiste à poser une question qui divise en deux sous

ensembles, de même tailles, le nombre de solutions possibles. Ex1: ton nombre est-il plus petit que dn/2e ? Ex2: ton nombre est-il impair?

Au début : n solutions possibles et, après avoir obtenu la réponse à une question « optimale », il reste dn/2e solutions possibles.

Pire cas : le nombre de solutions restantes est toujours impair. C’est le cas lorsque n = 2k + 1 (n>1) Après 1 question, il reste d(2k + 1)/2e = 2k-1 + 1 solutions possibles Après k questions, il ne reste que 20 + 1 solutions possibles Il faut alors k + 1 = lg(n-1) + 1 questions pour trouver la solution. Pour n – 1 = 2k, on a lg(n-1) + 1 = blg(n-1)c + 1 = dlg(n)e

Nous devons poser dlg(n)e questions en pire cas pour obtenir la solution


Minorants informationnels (suite)

Problème du tri par comparaisons

Pour trier un tableau d’éléments distincts, nous devons effectuer une seule permutation parmi les n! permutations possibles

Lorsque nous comparons deux éléments entre eux, cela élimine la moitié des permutations possibles.

Chaque comparaison divise par deux le nombre de solutions possibles. Mais, cette fois-ci, le nombre de solutions possibles est n!

Il faut alors dlog(n!)e 2 (n log n) comparaisons en pire cas Tout algorithme de tri par comparaisons nécessite donc, en pire cas,

(n log n) comparaisons.


Minorants informationnels (suite)

Problème du tri par comparaisons Exemple. Tableau 3, 2, 4,1 (n=4 éléments)

On devrait considérer 4! = 24 permutations, une de ses permutations donne le tri en ordre croissant.

Les 24 permutations

1,2,3,4 3,4,1,2

1,2,4,3 3,4,2,1

1,4,2,3 3,1,4,2

1,4,3,2 3,1,2,4

1,3,4,2 3,2,4,1

1,3,2,4 3,2,1,4

2,1,4,3 4,1,2,3

2,1,3,4 4,2,1,3

2,4,1,3 4,2,3,1

2,4,3,1 4,1,3,2

2,3,4,1 4,3,1,2

2,3,1,4 4,3,2,1

• Si on compare 3 avec 4 (3 doit venir avant 4), on aurait pu éliminer la moitié des 24 permutations (les permutations qui devraient être uniquement considérés sont en vert, rouge): on ne devrait considérer que la moitié = 12• Si on compare maintenant 1 et 2, on ne devrait donc considérer que la moitié des 12 permutations, celles en rouge uniquement: 6 permutation en tout.• Si on compare 1 et 3 maintenant, on va encore éliminer la moitié des permutations en rouge, il reste: (1,2,3,4), (1,3,4,2), (1,3,2,4)• Si on compare maintenant 2 et 4, il restera: (1,2,3,4) et (1,3,2,4).• Si on compare 2 et 3 maintenant, il nous restera alors qu’une permutation, (1,2,3,4). C’est la permutation recherchée.• Il faut bien comprendre le parallèle qui a été fait avec le problème qui a été résolu qui consiste à trouver une nombre entre 1 et n et le tri à base de comparaison pour trouver le minorant correspondant à ce dernier.


Algorithmes à temps polynomial

Un algorithme solutionne un problème en temps polynomial lorsque son temps d’exécution, en pire cas est 2 O(p(n)) où p(n) désigne une fonction polynomiale de n.

Note1: t(n) 2 O(p(n)) ssi il existe un entier fini k, indépendant de n, tel que t(n) 2 O(nk)

Note2: log(n) 2 O(n). Les algorithmes dont le temps 2 O(log n) sont des algorithmes à temps polynomial. Même remarque pour les algorithmes dont le temps d’exécution 2 O(n log n) …

Les problèmes solvables par un algorithme à temps polynomial sont dits traitables (faciles).

C’est la majorité des problèmes que nous avons traité jusqu’ici: trier un tableau, trouver le k-ième plus petit élément, trouver l’arbre de recouvrement minimal…

Les problèmes non solvables par un algorithme à temps polynomial sont dits intraitables (difficiles).


Types de problèmes

Décision (ou vérification). Résultat = vrai ou faux. Exemple trouver si X appartient à un ensemble.

Existentiels. Trouver ou produire une donnée qui vérifie une condition.

Optimisation. Trouver ou produire une donnée correspondant à l'extrêmum d’une

fonction (min ou max).

Énumération. Trouver ou produire toutes les données qui vérifient une

condition. Exemple: tous les chemins entre 2 sommets dans un graphe.


Problèmes de décision

Un problème peut être intraitable simplement parce que la solution qu’il doit produire est de trop grande taille

Ex: Pour le problème de trouver toutes les permutations de n entiers distincts, l’algorithme doit, au minimum, produire à sa sortie toutes les n! permutations possibles. Alors tout algorithme pour ce problème doit s’exécuter en temps (n!).

Pour éliminer ces cas (triviaux) d’ « intraitabilité », considérons les problèmes de décision: les problèmes dont la solution est oui ou non.

Exemple: Ayant un graphe connexe G = hV, Ei et un nombre k, existe-t-il un arbre de recouvrement dont le poids est au plus k?

L’algorithme solutionnant ce problème doit uniquement répondre oui ou non (pour n’importe quelle instance)

Les problèmes d’optimisation possèdent un problème de décision qui lui est très relié.


La classe P

La classe P est l’ensemble des problèmes de décision qui sont solvables par un algorithme à temps polynomial.

Exemple: Le problème de décision précédent est dans P. En effet, pour le solutionner, il suffit d’exécuter un algorithme à temps

polynomial (comme celui de Kruskal) pour trouver un arbre de recouvrement minimal du graphe G. Soit w la somme des poids de cet arbre. Si w · k, on retourne « oui ». Autrement, on retourne « non ».

Est-ce que tous les problèmes de décision sont dans P? Réponse: non! Il existe des problèmes de décision pour lesquels il n’existe aucun

algorithme qui puisse les résoudre! (peu importe leur temps d’exécution)


L’importance de la classe P

En général, on considère que les problèmes dans P sont des problèmes pour lesquels il existe un algorithme efficace. (Mais on exagère…)

Certainement, si un problème n’est pas dans P, alors il n’existe pas d’algorithme efficace pour le résoudre.

Que contient P? Malheureusement, on ne le sait pas précisément! Une liste partielle existe dans tous les livres d’algorithmique…

Opérations sur les entiers, algèbre matricielle, problèmes de tri, construction d’un arbre de recouvrement etc.


Indécidabilité

Un problème est dit indécidable lorsqu’il n’existe aucun algorithme qui puisse le résoudre.

Exemple: Le problème de l’arrêt (proposé par Alan Turing en 1936): Soit un programme informatique et une entrée à ce programme,

déterminez si ce programme va terminer sur cette entrée ou continuer à exécuter indéfiniment.

Théorème: le problème de l’arrêt est indécidable. Preuve (par contradiction):

Soit un algorithme A qui résout le problème de l’arrêt. Dans ce cas, pour tout programme P et entrée E, nous avons:

L’indécidabilité est une forme d’« intraitabilité » définitive. Lorsqu’un problème est indécidable, il n’existe pas d’algorithme qui puisse le résoudre. (peu importe son temps d’exécution)


Problèmes (présentement) intraitables mais décidables

Il existe plusieurs problèmes décidables qui sont présentement solvables uniquement par un algorithme à temps supra polynomial

Ces problèmes sont donc « présentement intraitables » mais ils pourraient éventuellement devenir « traitables » si l’on trouve un algorithme à temps polynomial pour les résoudre

Exemples: Cycle hamiltonien: déterminez si un graphe connexe (non orienté)

possède un cycle hamiltonien (un cycle parcourant chaque sommet une seule fois)

Commis voyageur: trouver le circuit de longueur minimal parcourant n villes. Chaque paire de villes est connectée par une arête de distance entière.

Sac à dos: parmi n objets, trouvez le sous-ensemble de valeur totale maximale dont le poids total n’excède pas la capacité du sac à dos.

Et plusieurs autres…


Vérification d’une solution proposée

Cycle hamiltonien est un problème de décision. Les deux autres sont des problèmes d’optimisation. Voici leur versions décisionnelles:

Commis voyageur décision: Soit n villes et un entier d. Existe-t-il un circuit de longueur au plus d qui parcourt les n villes?

Sac à dos décision: Soit n objets avec poids w1, ..., wn, et valeurs v1, …, vn, et un sac à dos de capacité W et un nombre V. Existe-t-il un sous ensemble de ces objets tel que le poids total est au plus W et tel que la valeur totale est au moins V.

Ces problèmes ont en commun le fait qu’il est facile de vérifier si une solution proposée (ou candidate) est une solution valide au problème.

Exemple: pour vérifier si une liste de nœuds est un cycle hamiltonien d’un graphe de n nœuds, il suffit de vérifier

que cette liste possède n + 1 nœuds les n premiers nœuds sont distincts le dernier nœud est identique au premier chaque paire de nœuds consécutifs est reliée par une arête.

Cette vérification s’effectue en temps polynomial en la taille du graphe.


Certificats succincts et systèmes de preuves

Une solution proposée pour une instance x « oui » est dit un certificat, i.e., une preuve que x est une instance « oui ».

Le certificat est dit succinct lorsque sa taille est polynomiale. À un problème de décision correspond X un ensemble d’instances « oui »

x 2 X lorsque x est une instance « oui » Soit Q l’ensemble des certificats possibles pour un problème X Un système de preuves pour X est un ensemble F µ X £ Q de paires (x,q) tel

que nous avons: 8 x 2 X, 9 q 2 Q : (x,q) 2 F En plus d’un système de preuve F pour X, il faut pouvoir vérifier qu’une paire

(x,q) 2 F. Il faut donc un algorithme de vérification.


Algorithmes de vérification

Un algorithme de vérification pour un système de preuves F µ X £ Q d’un problème de décision X est un algorithme A tel que:

A(x,q) = 1 lorsque (x,q) 2 F Lorsque (x,q) F, A peut retourner 0 ou exécuter indéfiniment.

Un système de preuves muni d’un algorithme de vérification est appelé un système de preuves vérifiables.

Un algorithme de vérification A(x,q) est à temps polynomial ssi son temps d’exécution est 2 O((|x|+|q|)k) pour une constante k.

Ainsi, un algorithme de vérification à temps polynomial pour un système de preuves F µ X £ Q d’un problème de décision X est un algorithme A tel que:

A(x,q) termine en un temps 2 O((|x|+|q|)k) pour une constante k. A(x,q) = 1 si (x,q) 2 F A(x,q) = 0 si (x,q) F


La classe NP

La classe NP est l’ensemble des problèmes de décision qui admettent un système de preuves succinctes vérifiables en temps polynomial.

Théorème: P µ NP.

Les problèmes suivants sont tous dans NP. Cycle hamiltonien, Commis voyageur décision, Sac à dos décision Pour prouver cela il suffit de démonter qu’ils possèdent tous un système de

preuves succinctes vérifiables en temps polynomial. Exemple du Cycle hamiltonien:

le système de preuves est l’ensemble de paires (g, ) où g est un graphe hamiltonien et est une liste de nœuds. L’algorithme de vérification A(g,) n’a qu’à parcourir et vérifier:

Si chaque paire de nœuds consécutifs dans cette liste est une arête appartenant à g.

Si cette liste comprends n+1 nœuds avec n = nombre de nœuds de g. Si le premier nœud de cette liste est le même que le dernier nœud. Si les n premiers nœuds sont distincts.

Cette vérification nécessite uniquement un temps polynomial en |g|+||.


La classe NP

NP signifie « Nondeterministic Polynomial-time » : si, pour une instance x 2 X, nous obtenons, de manière « non déterministe », une preuve q (que x 2 X), nous pouvons vérifier ce fait en temps polynomial (à l’aide d’un algorithme de vérification).

En d’autres mots, le non déterministe réside dans le fait que l’on peut supposer qu’une solution peut être « devinée » par un moyen quelconque.

Intuitivement, les problèmes dans NP sont tous des problèmes qui peuvent être résolus en énumérant l’ensemble des solutions possibles et en les testant avec des algorithmes en temps polynomial.

Pour déterminer si un problème est dans NP, il suffit de le réduire à un problème de décision. Ensuite, si par un algorithme en temps polynomial on arrive à vérifier une solution « oui » du problème, alors le problème est dans NP.


Exemples de problèmes dans NP (suite)

Cycle hamiltonien, Commis voyageur décision, Sac à dos décision Ces 3 problèmes suivants sont donc dans NP mais nous ne savons

pas s’ils sont dans P car, en dépit de nombreuses années d’effort, nous n’avons toujours pas trouvé d’algorithmes à temps polynomiaux pour les résoudre et nous n’avons pas encore pu démontrer que ces problèmes ne peuvent pas être résolus en temps polynomial.

La vaste majorité des problèmes de décision (bien posés) se trouvent dans NP. C’est donc une vaste classe de problèmes.

L’exemple le plus connu d’un problème de décision qui n’est pas dans NP est le problème de l’arrêt:

Théorème: le problème de l’arrêt n’est pas dans NP. Nous savons que P µ NP et que tous les problèmes de NP sont résolubles

par un algorithme qui, au pire, est à temps exponentiel. Mais existe-t-il des problèmes de NP qui ne sont pas dans P? En d’autres mots: Est-ce que P NP ou bien P = NP ?

Personne de connaît la réponse à cette question! Il s’agit de la question ouverte la plus importante en informatique!


Polynomialement Turing-réductible

Pour définir la classe NP-complets, introduisons le concept suivant: Un problème A est polynomialement Turing-réductible (PTR) à un

problème B ssi il existe un algorithme à temps polynomial A pour résoudre A qui utilise, à coût unitaire, un algorithme B pour résoudre B.

Réductibilité : un problème X peut être ramené (réduit) à un autre problème X’ si une instance quelconque de X peut être facilement reformulée comme une instance de X’ dont la solution sera aussi solution pour X.

La conséquence importante de la réductibilité de A à B est que : si l’on peut montrer que A est dans NP alors B l’est aussi si l’on peut montrer que B est dans P alors A l’est aussi

De façon générale, si l’on sait résoudre efficacement un problème, il est fréquent qu’on puisse en résoudre bien d’autres

Exemple :Le problème de coloration de graphe permet de modéliser, moyennant quelques modifications,aussi bien les problèmes de coloration de carte que des problèmes d’affectation de ressources.


Problèmes NP-complets et NP-difficiles

Un problème A est NP-difficile ssi tout problème dans NP est PTR à A. Un problème est NP-difficile s’il est au moins aussi difficile que tous les

autres problèmes dans NP. Donc, si un problème NP-difficile est résoluble en temps polynomial, alors

tous les problèmes de NP seront résolubles en temps polynomial (et donc P = NP).

Un problème de décision X est NP-complet ssi: X est dans NP et X est NP-difficile

Les problèmes NP-complets sont donc les problèmes de NP qui sont les plus « intraitables ».

Le fait de démontrer qu’un problème A est NP-complet donne un fort indice de son intraitabilité car un algorithme à temps polynomial pour résoudre A pourrait résoudre, en temps polynomial, tous les problèmes de NP.

Le théorème suivant sert à démontrer qu’un problème est NP-difficile Théorème: s’il existe un problème NP-difficile A (ou NP-complet) qui

est PTR à un problème B, alors B est NP-difficile.


Problèmes NP-complets et NP-difficiles (suite)

Pour le 1er problème NP-difficile, il a fallu démontrer que tous les problèmes de NP sont réductibles en temps polynomial à ce problème!

Ce tour de force fut réalisé indépendamment par Stephen Cook en 1971 et par Leonid Levin en 1973.

Cook démontra que CNF-SAT est NP-complet. Une expression booléenne CNF (de forme normale conjonctive) est de la

forme (une CNF d’ordre 3): (x1 Ç :x2 Ç :x3) Æ (:x1 Ç x2) Æ (:x1 Ç :x2 Ç :x3)

CNF-SAT est le problème qui consiste à déterminer si, oui ou non, une expression CNF est satisfaite (i.e. est « vrai ») par une certaine assignation aux variables d’entrée xi

Exemple l’expression CNF ci-haut est satisfaite par l’assignation (x1, x2, x3) = (vrai, vrai, faux).

La preuve que tous les problèmes de NP sont réductibles en temps polynomial à CNF-SAT est un chef-d’œuvre (et dépasse largement les objectifs du cours…)


Que faire lorsque c’est NP-Complet?

De nombreux problèmes d’intérêt pratique sont NP-Complets et sont trop important pour les ignorer.

Lorsque notre problème d’optimisation est NP-Complet, nous pouvons tenter de trouver une solution quasi-optimale (à la place d’une solution optimale).

Le prochain chapitre traite des approches algorithmiques nous permettant de trouver des solutions non optimales mais qui peuvent parfois être très satisfaisantes.

Exemples de problèmes NP-Complets CNF-SAT Coloriage de graphes Existence d’une clique de taille k dans un graphe. Le pb du sac à dos (non entier). Le pb de l’existence d’un circuit hamiltonien. Le pb du voyageur de commerce. Etc…

http://fr.wikipedia.org/wiki/21_probl%C3%A8mes_NP-complets_de_Karp


Les différents ensembles de complexité


Activités dans la semaine

Lectures. Livre de Levitin: Chapitre 11, sections 11.1, 11.2 et 11.3 Diapos à visionner: chapitre 10 Exercices: série 8,

Exercices # 5, 7, 8, 9 et 10Exercices: série 9

Exercices # 1, 2, 3, 4, 6, 7 et 8.

Documentation fournie• Aide mémoire (celui fourni lors des examens)• Annexe A du livre de Levitin (enrichi…)

Documents

Mario MarchandIFT-17588 (Automne 2005)1 Conception et analyse dalgorithme Cours sur Elluminate : Mardi 13h30 à 15h, mercredi 14h à 15h30 Atelier sur Elluminate