algorithmique et complexité algorithmes gloutons

Algorithmique et Complexité

Partie II

Emmanuel Hebrard et Mohamed Siala

Algorithmes gloutons

Algorithmes gloutons 2 / 83

Rappel

Nous avons traité deux types de problèmes :I Les problèmes de décision : Trouver une solution qui satisfait des critères (i.e., problème

de tri, problème de recherche d’élément, PGCD, etc)I Les problèmes d’optimisation : Trouver une solution qui satisfait des critères et qui

minimise ou maximise un coût (e.g., parenthèsage pour la multiplication de matrices). Lecoût dans ce cas s’associe à une “fonction objectif”.

Nous avons étudié différentes approches de résolutions :

I L’approche force brute (recherche exhaustive, énumération)I Paradigme diviser pour régner (et les algorithmes récursifs)I Programmation dynamique

On découvre aujourd’hui une nouvelle approche de résolution (l’approche gloutonne)et une jolie structure de représentation de problèmes qui s’appelle “les matroïdes”


Algorithmes gloutons (Greedy algorithms)

Contexte : typiquement pour les problèmes d’optimisation

Idée de base :

I Résoudre le problème en une séquence d’étapes/choixI Pour chaque étape, faire un choix qui semble optimal à l’étape courante

Avantage : Rapide en temps de calcul

Inconvénient : Pas de garantie sur l’optimalité


Exemple : Problème du Voyageur de commerce

Voyageur de commerce (optimisation)

donnée : ensemble de villes

question : quel est le plus court cycle passant par toutes les villes une seule fois ?


Figure – Instance du problème du voyageur de commerce sous forme de graphe

c

b

a

d

7

15

34

2


Figure – Une solution non optimale

c

b

a

d

7

15

34

2

Cycle : a,b,c,d,a

Coût de la solution :7 + 3 + 2 + 5 = 17


Figure – Une solution optimale

c

b

a

d

7

15

34

2

Cycle : a,c,b,d,a

Coût de la solution :1 + 3 + 4 + 5 = 13


Énumération exhaustive ?

2 Villes –> 1

3 Villes –> 1

4 Villes –> 3

5 Villes –> 12

n Villes –> (n−1)!2 (la moitié du nombre de permutations possible de taille n − 1)

40 villes –> à peu près 1046 solutions à tester !

Avec une machine moderne : 3× 1029 années (plus que AgeUnivers3) !

La recherche exhaustive est inefficace ! !


Algorithme Glouton

Idée gloutonne :

I Construction de la solution ville par ville selon l’ordre de visiteI À partir de la dernière ville visitée, choisir la ville la plus proche qui est non visitée.I Arrêter quand on visite toutes les villesI Ajouter la première ville pour construire un cycle.


Figure – Construction de la solution gloutonne étape par étape : Initialisation àpartir de “a”

c

b

a

d

7

15

34

2

Chemin initial : a

Coût initial :0


Figure – Construction de la solution gloutonne étape par étape

c

b

a

d

7

15

34

2

Cycle : a,c,d, b, a

Coût courant :1 + 2 + 4 + 7 = 14

C’est la solution retournée par l’algorithme glouton

Ce n’est pas une solution optimale mais c’est assez rapide à trouver


Algorithme Glouton pour le voyageur decommerce

Algorithme : Glouton (n, distance)

Données : n ∈ N∗ : nombre de villes, distance[i ][j] ∈ R+ : la distance entre ville i et ville jRésultat : Permutation de 1, . . . , ndébut

Ensemble ← 1, . . . n ;element ← 1 ;Permutation ← element ;Ensemble ← Ensemble \ element ;tant que |Permutation| < n faire

min ← +∞ ;pour e ∈ Ensemble faire

si distance[element][e] < min alorsmin ← distance[element][e] ;ville ← e ;

Permutation ← Permutation, ville ; // Ajouter ville à la fin de PermutationEnsemble ← Ensemble \ ville ;element ← ville ;

retourner Permutation ;

Complexité : O(n2)


Matroïdes

Résoudre des problèmes d’optimisation avec des algorithmes gloutons

Un matroïde représente une structure particulière utilisée pour concevoir unalgorithme glouton optimal


Définition

Un matroïde est un coupleM = (E , I) qui satisfait les conditions suivantes :

I E est un ensemble fini non videI I est un ensemble de sous ensembles de E tel que :

F Si H ∈ I, et F ⊂ H, alors F ∈ I (on dit que I est héréditaire)F Si F ∈ I, H ∈ I et |F | < |H|, alors ∃x ∈ H \ F tel que F ∪ x ∈ I (propriété d’échange)

SiM = (E , I) est un matroïde et H ∈ I, alors H est appelé “sous ensembleindépendant”


Exemple (simple) de Matroïde

E = 1, 2, 3, 4I = , 1, 2, 4, 1, 4, 2, 4Preuve

I E est un ensemble fini non vide (évident)I I est héréditaire car :

F Pour 2, 4 : ∈ I , 2 ∈ I , 4 ∈ IF Pour 1, 4 : ∈ I , 1 ∈ I , 4 ∈ IF Pour 1 : ∈ I , 1 ∈ IF Pour 2 : ∈ I , 2 ∈ IF Pour 3 : ∈ I , 4 ∈ IF Pour : ∈ I

I Propriété d’échange :F Pour H = 1, 4 et F = 2 : F ∪ 4 ∈ IF Pour H = 2, 4 et F = 1 : F ∪ 2 ∈ IF Pour H = 4 et F = : F ∪ 4 ∈ IF . . .


Matroïde pondéré

SoitM = (E , I) un matroïde

M est pondéré s’il existe une fonction de poids pour les éléments de E . Pour chaquex ∈ E , w(x) ∈ R+∗ est le poids de x .

Si F est un sous ensemble de E , alors le poids de F se définit avecw(F ) =

∑x∈F w(x)

Problème de sous ensemble indépendant de poids maximal :I Donnée :M = (E, I) : matroïde et w : fonction de poidsI Question : Trouver F ∈ I de poids maximal


Algorithme glouton

Algorithme : Glouton (M(E, I) , w)

Données :M(E, I) : matroïde, w : fonction de poidsRésultat : Sous ensemble indépendant de E (probablement de poids maximal)début

F ← ;n← |E| ;L← Trier(E) par poids décroissant ;pour i ∈ [1..n] faire

si F ∪ L[i ] ∈ I alorsF ← F ∪ L[i ];

retourner F ;

Complexité : Si le test d’appartenance (ligne 7) se fait en O(f (n)), alorsla complexité de Glouton (M(E , I) , w) est O(nlog(n) + nf (n)) avecn = |E| (car le tri peut se faire en O(nlog(n))).


L’importance des matroïdes

TheoremGlouton (M(E , I) , w) retourne un sous ensemble indépendant optimal

Algorithme : Glouton (M(E, I) , w)

Données :M(E, I) : matroïde, w : fonction de poidsRésultat : Sous ensemble indépendant de E de poids maximaldébut

F ← ;n← |E| ;L← Trier(E) par poids décroissant ;pour i ∈ [1..n] faire

si F ∪ L[i ] ∈ I alorsF ← F ∪ L[i ];

retourner F ;


Glouton (M(E , I) , w), alors ?

Rappel pour un problème d’optimisation :

I Une solution est une sortie qui respecte les exigences du problèmeI Une solution optimale est une solution qui (minimise ou maximise) une fonction

(objectif).I Le coût d’une solution est la valeur correspondante à la fonction objectif

Pour exploiter Glouton (M(E , I) , w) pour un problème d’optimisation P :I Il faut trouver un matroïdeM(E, I) pondéré tel qu’une solution optimale de P

correspond à un sous ensemble indépendant (i.e., élément de I) de poids maximal qu’onpeut calculer à partir de Glouton (M(E, I) , w).

I Dans ce cas, l’algorithme glouton est garanti de retourner une solution optimale

Cette approche ne marche pas pour tous les problèmes. En particulier, il y a souventdeux limites :1 Difficulté à définir l’ensemble I des sous ensembles indépendants2 Même si on trouve I , le test d’appartenance (F ∈ I?) est coûteux en temps (par exemple

quand f (n) = O(2n).


Représentation des Données

Représentation des Données 24 / 83

Complexité en fonction de la taille de la donnée

Pourquoi calculer la complexité en fonction de la taille de la donnée ?

Sinon quel paramètre choisir ?I Multiplication de x par y : en fonction de x ? de y ? de x + y ? de xy ?

Sinon comment comparer des algorithmes avec des données différentes ?I Est-ce que Factorielle est plus efficace que triSélection ?

I Factorielle : Θ(x) opérations, |x | = log2 x , donc Θ(2|x|) opérations

I triSélection : Θ(n2) opérations, |T | = n, donc ≥ Θ(|L|2) opérations

Comment connaitre la taille de la donnée ?


Calculer la taille de la donnée

On compte le nombre de bits mémoire, en ordre de grandeur (Θ)

Exemples :

I Types char, int, float, etc. : O(1)

I Type N : Θ(log n) (pour un entier ≤ n)

I Type liste d’int : Θ(n) (pour une liste de longueur ≤ n)

Borne supérieure (O)Trouver un encodage

Borne inférieure (Ω)

Principe des tiroirs


Encodage

EncodageUn encodage pour un type de donnée T est une fonction injective :

f : T 7→ 0, 1k

Tout x ∈ T a un seul code f (x) (fonction)I Sinon on ne peut pas toujours encoder

Pour x , y ∈ T distincts, f (x) 6= f (y) (injective)I Sinon on ne peut pas toujours decoder

Exemples : ASCII, Morse,...


Encodage d’un char

0 1 0 0 1 0 1 1

01234567

2021222324252627

Représenter les entiers entre 0 et 255 (char)

Chaque bit repésente un terme de la somme x =7∑

i=0bi2i

Pour x = 75 : 1× 26 + 1× 23 + 1× 21 + 1× 20

Borne supérieure (et inféreieure)

Si c est de type “char” alors |c | ∈ O(1), et donc |c | ∈ Θ(1)


Encodage d’un entier n ∈ N

0 0 0 0 0 0 0 1 0 0 1 0 1 1

20212223242526

27

︸︷︷︸N de 0 = N de bits =7

Code en base 2 : O(log2 n) pour coder tout entier naturel ≤ n

Problème : combien de bits allouer pour coder n’importe quel entier ? ∞ ?

Donner le nombre de bits “utiles” en préfixe, en code unaire (autant de 0 que de bitssignificatifs)

Code en O(log2(n)) pour le préfixe + O(log2(n)) pour le suffixe

Borne supérieureSi n ∈ N alors |n| ∈ O(log n)


Encodage d’un tableau de n int

8 13 0 3 −18 2 9 11 −4

size L[0] L[1] L[2] L[3] L[4] L[5] L[6] L[7]

Chaque int requiert 4 octets : n ×O(1)

Même astuce que pour les entiers, le nombre d’éléments en préfixe : O(log n)

n ×O(1) +O(log n) = O(n)

Borne supérieureSi L est un tableau contenant n int, alors |L| ∈ O(n)


Borne inférieure sur la taille de la donnée

Quelques principes de base de dénombrement

Principe additifLes choix mutuellement exclusifs se combinent par addition.

Ex : combien de choix possibles de plats principal si on a 3 types de viande, 2 poissonet 3 plats végétariens ? 3 + 2 + 3 = 8 plats

Principe multiplicatifLes choix indépendents se combinent par multiplication.

Combien de menus s’il y a 3 entrées, 4 plats, et 4 desserts ? 3× 4× 4 = 48 menus

Combien de valeurs possibles pour un int sur 32 bits ? 232 valeurs


Principes des tiroirs

Principe des tiroirsSi m objets sont rangés dans n tiroirs, alors un tiroir en contient au moins dmn e.

Si m > n objets sont rangés dans n tiroirs, alors un tiroir en contient au moins 2

Il y a deux londoniens avec exactement le même nombre de cheveux

I Il n’y a pas plus d’un million de cheveux sur un crâne, donc pas plus d’un million denombres de cheveux distincts

I Il y a plus d’un million de londoniens

I m londoniens à répartir parmi n chevelures possibles ⇒ au moins deux londoniens avec lamême chevelure


Minorant pour l’espace mémoire

un encodage est une fonction injective d’un type de donnée vers les mots binaires :

f : T 7→ 0, 1k avec f (x) ∈ 0, 1|x|

Il y a 2k mots binaires de longueur k (Principe multiplicatif)

Il faut au moins autant de mots binaires que de valeurs possibles pour la donnée

I Principe des tiroirs : sinon, des données distinctes ont le même code, et f est non-injective

Minorant pour la taille |x | d’une donnée x de type TSoit #(T ) le nombre de valeurs possibles du type de donnée T , la mémoire|x | nécessaire pour stocker une donné x ∈ T est telle que 2|x | ≥ #(T ), ⇒

|x | ∈ Ω(log#(T ))


Bornes inférieures

Calculons #(T ), le nombre de valeurs possibles pour la donnée x de type T :

I Entier naturel inférieur ou égal à n : n + 1, soit Θ(n)

Pour x un entier naturel inférieur ou égal à n :

|x | ∈ Ω(log n) et puisqu’il existe un encodage tel que |x | ∈ O(log n), alors |x | ∈ Θ(log n)

I Tableau d’int de longueur n : (232)n, soit Θ(232n)

I Tableau d’int de longueur ≤ n :n∑

i=0232i , soit Θ(232n)

I log2(232n) = 32nlog2(2) = 32n

Pour L un tableau d’int de longueur ≤ n :

|L| ∈ Ω(n) et puisqu’il existe un encodage tel que |L| ∈ O(n), alors |L| ∈ Θ(n)


Complexité en fonction de la taille de la donnée

L’algorithme A est en Θ(f (x)) pour une donnée x

La taille |x | de la donnée est en Θ(g(x))

Alors la complexité de A est en Θ(f (g−1(x)))

Exemple

Algorithme : Carré(x)Données : un entier xRésultat : un entier valant x2

r : entier;début

r ← 0;pour i allant de 1 à x faire

pour j allant de 1 à x fairer ← r + 1;

retourner r ;

Complexité : Θ(x2)

Taille de la donnée |x | = Θ(log x)

Autrement dit, x = Θ(2|x|)

Donc complexité en Θ(22|x|) (exponentielle !)


Structure de données

Le choix de la structure de données est très important dans la conceptiond’un algorithme

Choisir la structure pour laquelle les opérations utiles sont les plus efficaces

Un type abstrait est défini par les opérations qui sont efficaces sur ce type

I Insertion (I) : ajouter un nouvel élémentI test d’Appartenance (A) : vérifier si l’élément x est présentI Suppression (S) : supprimer un élément xI Suppression du Dernier (SD) : supprimer le dernier élément inséréI Suppression du Premier (SP) : supprimer le premier élément inséréI Suppression du Minimum (SM) : supprimer l’élément minimum


Structure de données

Un type abstrait est défini par les opérations qui sont efficaces sur ce type

Une réalisation correspond à du code (des algorithmes)

Type Abstrait Réalisation I A S SP SD SMPile Liste chainée O(1) Θ(n) Θ(n) Θ(n) O(1) Θ(n)

Liste chainée avecFile pointeurs début et fin O(1) Θ(n) Θ(n) O(1) Θ(n) Θ(n)

Index statique Vecteur trié Θ(n) O(log n) Θ(n) N/A N/A Θ(n)File de priorité Tas binaire O(log n) Θ(n) Θ(n) N/A N/A O(log n)

Ensemble Table de hâchage O(1)∗ O(1)∗O(1)Θ(n) Θ(n)

N/A N/A Θ(n)

Ensemble trié ABR, AVLArbre rouge-noir O(log n) O(log n) O(log n) N/A N/A O(log n)


Exemple : Table de Hâchage

Fichier des étudiants de l’INSA, il faut une clé unique pour identification

Tatouer chaque étudiant avec son numéro d’inscrit (1, . . . , n) ?I Une table T avec T [x] contenant les informations pour l’étudiant x

Utiliser le numéro de sécurité sociale ?I Beaucoup trop de clés possibles !

Table de Hâchage : n enregistrements / table de taille m ∈ Θ(n)

Soit U l’ensemble des clés possibles, avec |U| = M,m M

Soit h : U 7→ 1, . . . ,m un fonction de hâchage : renvoie un index pour chaque clé,par ex. h(x) = ((ax + b) mod p) mod m) avec m p M premier et 0 < a, b < p

L’enregistrement de clé x est stocké dans T [h(x)]. Si h(x) = h(y) et x 6= y on ditqu’il y a une collision


Exemple : Table de Hâchage

T [i ]T [i − 1] T [i + 1]

enregistrement(x)

enregistrement(y)

h(x) = h(y) = i

Analyse de la complexité du test d’appartenance (A)

I Pire des cas Tmax(n) = Θ(n) (tous les enregistrements ont la même valeur de hâchage)I Pour Tmoy (n) on suppose une distribution uniforme des valeurs de h(x) dans 1, . . . ,m

I Soit Li la longueur de la liste T [i ], et E(Li ) l’espérance de Li :m∑i=1

E(Li ) = n

I Mais E(Li ) ne dépend pas de i , donc Tmoy (n) = E(Li ) = n/m ∈ O(1)


Exemple : Tas BinaireInvariants : arbre binaire complet ; sommet parent ≤ fils

2

5

8

12 95

67

6

50 38

2

5

8

12 95

67

3

6

50 38

2

5

8

12 95

3

67

6

50 38

2

3

8

12 95

5

67

6

50 38

2

3

8

12 95

5

67

6

50 38

2

3

8

12 95

5

67

6

50 38

67

3

8

12 95

5

6

50 38

3

67

8

12 95

5

6

50 38

3

5

8

12 95

67

6

50 38

1

2 3

4 5 6 7

8 9

réalisation :1 2 3 4 5 6 7 8 9 10

22673 533675 6 8 673567 50 38 12 95 .367parent de i : bi/2cfils gauche de i : 2ifils droit de i : 2i + 1

Insertion : la position libre la plus à gauche possible sur le dernier niveauI Percolation échange avec le parent jusqu’à ce que l’invariant soit rétabli O(log n)

Suppression du minimum : la racine, qu’on remplace par le “dernier” sommetI Percolation échange avec le fils minimum jusqu’à ce que l’invariant soit rétabli O(log n)


Tri par tas

Donnée : une liste L d’éléments comparablesPour chaque x ∈ L :

Insérer x dans le tas binaire H

Tant que H n’est pas vide :Extraire le minimum de H et l’afficher

n insertions en O(log n)

n suppressions en O(log n)

Complexité du tri par tas : O(n log n)

Tri par tas est optimal !

O(n log n) dans le pire des cas


Classes de Complexité

Classes de Complexité 42 / 83

Borne inférieure pour les algorithmes de tri

Tri par comparaison

donnée : une liste d’éléments comparables

question : quelle est la liste triée de ces éléments ?

Considérons les algorithmes de tri qui ne peuvent pas “lire” ces éléments, seulementles comparer (e.g. un tableau de pointeurs vers une classe d’objets comparables).

Lors de son execution, cet algorithme va comparer k paires d’éléments (x , y), lerésultat peut être 0 (x < y) ou 1 (x ≥ y)

On peut considérer que la donnée de l’algorithme est une table de longueur k avec lesrésultats des comparaisons :

x = [0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1]︸︷︷︸k



Un algorithme est deterministe, donc deux tables de comparaisons identiques donnentla même exécution, et donc la même liste triée

[0, 0, 1, 0, 1, 1, 1, 1, . . .][0, 0, 1, 0, 1, 1, 1, 1, . . .][0, 1, 0, 0, 1, 0, 0, 1, . . .][1, 0, 0, 0, 0, 1, 1, 1, . . .][0, 1, 1, 0, 1, 1, 0, 0, . . .][1, 0, 1, 0, 0, 1, 1, 0, . . .][0, 0, 1, 0, 1, 1, 1, 1, . . .]...

2k

(e1, e2, e3, e4, . . .)

(e1, e2, e4, e3, . . .)

(e1, e3, e2, e4, . . .)

(e1, e3, e4, e2, . . .)

(e1, e4, e2, e3, . . .)

(e1, e4, e3, e2, . . .)

(e1, e2, e3, e4, . . .)...

n!

Au plus k comparaisons, donc au plus 2k données/exécutions distinctes

Chacune des n! permutations de la donnée doit correspondre à une exécution distincte

principe des tiroirs

2k ≥ n!



2k ≥ n! =⇒ k ≥ log(n!)

= log(n(n − 1)(n − 2) . . . 2)

= log n + log(n − 1) + log(n − 2) + . . . + log(2)

=n∑

i=2

log i

=

n/2−1∑i=2

log i +n∑

i=n/2

log i

≥n∑

i=n/2

logn

2

=n

2log

n

2= Ω(n log n)



ThéorèmeTout algorithme de tri par comparaison est en Ω(n log n)

Attention, il existe des algorithmes de tri en O(n)

I Mais ces algorithmes font des hypothèses sur les éléments à trier

Dans le cas général d’éléments comparables sans propriété particulière : impossible deles trier avec une complexité dans le pire des cas inférieure à Ω(n log n)


La complexité d’un problème, à quoi ça sert ?

Pour pouvoir objectivement analyser un algorithmeI Optimalité

Parce que la difficulté du problème détermine le type de méthodeI solution approchée pour un problème difficile ?

Parce que la difficulté du problème est parfois une garantieI Cryptographie, Block Chain


Problème

Définition : Problème ' fonction sur les entiersUne question Q qui associe une donnée x à une réponse y

I “Quel est le plus court chemin de x1 vers x2 par le réseau R ?”I “Quel est la valeur du carré de x ?”

Qpcc : Réseau : R,Villes : x1, x2 7→ Route : x1, u1, u2, . . . , uk , x2

Qcarr : Entier : x 7→ Entier : x2


Types de Problèmes

Problèmes généraux (fonctions)

Problèmes d’optimisation : la solution est le minimum d’un ensemble

Problèmes de décision : la réponse est dans oui, non


Problème de décision

Problème de décision Q

Fonction Q : x 7→ oui,non

Pour un problème d’optimisation, on peut généralement définir un problèmepolynomialement équivalent dont la réponse est dans oui,non, :

Voyageur de commerce (optimisation)

donnée : ensemble de villes

question : quel est le plus court chemin passant par toutes les villes ?

Voyageur de commerce (décision)

donnée : ensemble de villes, entier k

question : est-ce qu’il existe un chemin de longueur inférieure à k passant par toutesles villes ?


Instance

Instance : problème avec la donnée (“Combien vaut 5672 ?”, “Quel est le plus courtchemin entre Toulouse et Paris ?”)

Ne pas confondre problème et instance

En particulier, se poser la question de la difficulté d’une instance n’a pas(beaucoup ?) de sens

I L’algorithme qui renvoie systématiquement, et sans calcul, la solution de cette instance(correct et en O(1))


Classes d’Algorithmes

Un algorithme est dit :

en temps constant si sa complexité dans le pire des cas est bornée par une constante

linéaire si sa complexité dans le pire des cas est en Θ(n)

quadratique si sa complexité dans le pire des cas est en Θ(n2)

polynomial si sa complexité dans le pire des cas est en O(nc) avec c > 0

exponentiel si elle est en Θ(2nc

) pour un certain c > 1


Classes de problèmes

Comment évaluer la complexité d’un problème ?

La complexité d’un problème :

La complexité du meilleur algorithme pour le résoudre

f (n)-TIME

Ensemble des problèmes pour lesquels il existe un algorithme en O(f (n))

Tri ∈ (n log n)-TIME

Recherche dans un tableau trié ∈ (log n)-TIME

Recherche du maximum dans un tableau ∈ (n)-TIME


Relation d’Inclusion

InclusionSi f (n) ∈ O(g(n)) alors f (n)-TIME ⊆ g(n)-TIME

(n log n)-TIME

n-TIME

(log n)-TIME

n2-TIME


Problème de Tri

Tri

donnée: Une liste L d’objet comparables

question: La séquence triée des objets de L

(n log n)-TIME(log n)-TIME

n-TIMETriMax ?

Tri ∈ (n log n)-TIME

Tout algorithme de tri est en Ω(n log n) =⇒ Tri 6∈ n-TIME

La recherche du maximum est dans n-TIME, dans (log n)-TIME ?


(Non-)Appartenance à une Classe

f (n)-TIME


Pour prouver qu’un problème appartient à la classe f (n)-TIME

I il suffit d’un algorithme en O(f (n))

Pour prouver qu’un problème n’appartient pas à une classe inférieure

I il faut montrer que tout algorithme est en Ω(f (n))


Classe “Temps Polynômial”

Rappel :

f (n)-TIME


Classe des problèmes pour lesquels il existe un algorithme polynômial :

P-TIME ou simplement : PEnsemble des problèmes pour lesquels il existe un algorithme en O(nc)pour une constante c .

P =⋃c≥0

nc -TIME


Classe “Temps Exponentiel”

Classe des problèmes pour lesquels il existe un algorithme exponentiel :

EXP-TIME :

Ensemble des problèmes pour lesquels il existe un algorithme en O(2nc)

pour une constante c

EXP-TIME =⋃c≥1

2nc-TIME

Evidemment, P ⊆ EXP-TIME

Est-ce que P ⊂ EXP-TIME ? Oui !

Il existe des problèmes en Ω(2n)

EXP-TIME P


Classes Caractérisées par l’Espace

On peut analyser l’espace mémoire utilisé par un algorithme de manière similaire

f (n)-SPACE

Ensemble des problèmes pour lesquels il existe un algorithme nécessitantO(f (n)) octets de mémoire

On ne compte pas la taille de la donnée, mais on compte la taille de la réponse


Exemple : Sous-Séquence Maximale

Sous-Séquence Maximale

donnée: Un tableau L avec n éléments dans −1, 1

question: Quelles sont les valeurs de s et e dans [1, n] qui maximisent∑ei=s L[i ]

-1 -1 1 1 -1 1 -1 1 1︸︷︷︸3

-1 -1 1 1 -1 1

Algorithme 1Pour chaque 1 ≤ i ≤ j ≤ n :calculer

∑jk=i L[k] ; garder le max.

Temps : Θ(n3)

Espace : Θ(log n)

I log n pour le max, la somme et le resultat


Exemple : Sous-Séquence Maximale

︷︸︸︷L[i ] 1 1 1 -1 -1 -1 -1 1 -1 -1 1 1 1 1 -1 -1 1 1 1 -1 -1 1 -1 1 -1 -1 -1

s[i ] 1 2 3 2 1 0 -1 0 -1 -2 -1 0 1 2 1 0 1 2 3 2 1 2 1 2 1 0 -1

min[i ] 0 0 0 0 0 0 0 -1 -1 -1 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2

max[i ] 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 2 2 2 2 1 0 -1

mss[i ] 3 3 3 3 3 3 3 4 4 4 5 5 5 5 5 5 5 5 5 4 4 4 4 4 3 2 1

Algorithme 2

s[i ] =∑i

k=1 L[k]

I∑j

k=i L[k] =∑j

k=1 L[k]−∑i−1

k=1 L[k]

min[i ] = min(s[j ] | j < i)

max[i ] = max(s[j ] | j ≥ i)

mss[i ] = maxi −mini

Θ(1) tables de taille Θ(n)

Temps : Θ(n)

Espace : Θ(n)


Temps ou Espace

Temps Espace

Algorithme 1 Θ(n3) Θ(log n)

Algorithme 2 Θ(n) Θ(n)


Temps ou Mémoire ?

Théorèmef (n)-TIME ⊆ f (n)-SPACE

Supposons qu’il existe un problème A t.q. A ∈ f (n)-TIME et A 6∈ f (n)-SPACE.

Alors tout algorithme pour A utilise Ω(g(n)) mémoire avec g(n) 6∈ O(f (n)).

Si un algorithme nécessite Ω(g(n)) mémoire il fait Ω(g(n)) écritures.

Autrement dit, il est en Ω(g(n)) temps (contradiction).

Donc A ∈ f (n)-TIME =⇒ A ∈ f (n)-SPACE.


Classe “Espace Polynomial”

Classe des problèmes pour lesquels il existe un algorithme polynômial en espace :

P-SPACEEnsemble des problèmes pour lesquels il existe un algorithme qui utiliseO(nc) octets de mémoire pour une constante c .

= P-SPACE⋃c≥0

nc -SPACE

Est-ce que P-SPACE est inclu dans EXP-TIME, EXP-TIME inclu dansP-SPACE, ou ni l’un ni l’autre ?


P-SPACE et EXP-TIME

ThéorèmeP-SPACE ⊆ EXP-TIME

Un problème A dans P-SPACE admet un algorithme qui utilise O(nc) octets

Cet algorithme est constitué de k ∈ Θ(1) instructions (' lignes de code)

La mémoire utilisée par cet algorithme peut être dans O(2(8n)c ) configurations

Il y a donc O(k2(8n)c ) = O(2(n)c ) configurations possibles

Si l’algorithme passe deux fois par la même configuration il ne s’arrête jamais

EXP-TIME P-SPACE P


Problèmes “intermédiaires”

Il y a un nombre infini de classes de complexité entre P et P-SPACE !

EXP-TIME P-SPACE ? P

Il existe des problèmes pour lesquels on ne connait pas d’algorithme en tempspolynômial, sans pouvoir prouver qu’ils n’en n’ont pas

Ces problèmes sont très nombreux...

... et très intéressants : Voyageur de Commerce, Programmation Linéaire en NombresEntiers, SAT , Isomorphisme de Graphes, etc.


Les Classes NP et coNP

Les Classes NP et coNP 67 / 83

Classes non-déterministes

EXP-TIME P-SPACE ?NP P

A priori difficiles (pas d’algorithme polynomial connu)

Faciles à vérifier, ex. Voyageur de Commerce

TSP

donnée: Un ensemble de villes S , une matrice de distance D : S × S 7→ N, un entier k

question: Est-ce qu’il existe une route de longueur au plus k passant par toutes les villes ?


Classes non-déterministes

Ces problèmes peuvent être résolus en espace polynomial

Pas d’algorithme en temps polynomial connu, mais aucune preuve d’impossibilité

Problèmes faciles pour des algorithmes non-déterministes

Algorithme non-déterministe pour le problème Q

Composée d’instructions primitives : exécutable par une machine

Déterministe : une seule exécution possible pour chaque donnée

Non-déterministe : peut deviner un certificat (par ex. la solution !)

Correct : termine et retourne la bonne solution Q(x) pour toute valeur de la donnée x


Oracle

Algorithme non-déterministe

Un algorithme non-déterministe peut avoir recours à un oracle qui, si la réponse est“oui” , devine un certificat polynomial en temps O(1)

Le certificat peut-être n’importe quoi, mais :

I Il faut pouvoir le coder en espace polynomial dans la taille de la donnéeI Il faut pouvoir prouver que “oui” est bien la réponse correcte en temps polynomial dltd

Quel certificat pour le problème du voyageur de commerce ?

TSP


question: Est-ce qu’il existe une route de longueur au plus k passant par toutes les villes ?

La séquence de villes : on peut vérifier la longueur de ce tour, et être convaincu quela réponse est correcte, même si on ne sait pas comment elle a été obtenue


Exemple : Le problème de 3-coloration

Donnée : Un graphe G = (S ,A) (sommets S ; arêtes A)

Question : Est-ce qu’il est possible de colorier les sommets de G avec auplus 3 couleurs en évitant que deux sommets adjacentspartagent la même couleur.

?


3-Coloration est dans NP

Certificat : La coloration (tableau – couleur du i-ème sommet dans la case i)

De taille polynomiale (dans la TDLD)

I quelle est la taille de la donnée du problème ?taille : |G | = Θ(|S |+ |A|)

I quelle est la taille du certificat ?taille : Θ(|S |)

Vérifiable en temps polynomial (dans la TDLD) : algorithme


Algorithme de vérification

Algorithme : verification(L,G)

Données : un graphe G = (S ,A) et un tableau TRésultat : vrai si T est une 3-coloration de G , faux sinondébut

pour chaque arrête (i , j) de A fairesi T [i ] = T [j ] alors

retourner faux ;

retourner vrai ;

Complexité : O(|A|) (liste d’adjacence)

⇒ 3-Coloration est bien dans NP


P et NP

P est la classe des problèmes “faciles à résoudre”

NP est la classe des problèmes “faciles à vérifier”

Est-ce qu’il y a une différence ? (500 000 e pour la bonne réponse !)

I On ne connait pas d’algorithme polynomial pour Voyageur de commerce ou 3-Coloration

I Mais personne ne sait s’il en existe !


P, NP et la Cryptographie

Système d’authentification A

comparaison entre

I une clé privée y (mot de passe / pin)I et une information publique x (login / carte bancaire)

autorise la transaction si et seulement si A(x) = y

Supposons que calculer A soit polynomial : trouver le mot de passe est facile !

Supposons que vérifier A(x) = y ne soit pas polynomial : authentifier est difficile !

La majorité des systèmes d’authentificationsont basés sur un problème A tel que A ∈ NP et A 6∈ P


L’importance de la classe NP

Ces problèmes sont partout : en intelligence artificielle, en cryptographie, dansl’industrie...Savoir adapter la méthode à la complexité du problème ; le problème du voyageur decommerce n’a pas d’algorithme polynomial connu, mais...I Domaine de recherche très actif, des algorithmes “intelligents” peuvent résoudre

(optimalement) de très grandes instances

115 475 villes


L’importance de la classe NP (suite)

Conjecture P 6= NP

Un des 7 “problèmes du millénaire” du Clay Mathematics InstituteMise-à-prix $1 000 000

Preuve de P 6= NP : un problème dans NP mais pas dans P

I Montrer qu’un problème est dans NP est facile : certificat polynomial

I Montrer qu’un problème n’est pas dans P est difficile : tout algorithme est en Ω(2n)

Prouver que P = NP ne nécessite qu’un algorithme ! (cours de 4ème année)


Et si l’oracle ne devine rien ?

La réponse “oui” est accompagnée d’un certificat grace auquel on peut vérifier que laréponse est correcte

Si la réponse est “non”...il faut faire confiance !

I Ou alors vérifier avec un algorithme qui n’est pas polynomial

Donc le problème suivant n’est pas forcément équivalent au problème du voyageur decommerce ?

co-TSP


question: Est-ce qu’il n’existe pas de route de longueur au plus k passant par toutes lesvilles ?


Problème complémenaire

Problème complémenaireLe Problème complémenaire co-A d’un problème de décision A, est leproblème qui associe la réponse “non” à toute donnée associée à “oui” dansA, et vice versa.

Si A est dans P alors co-A est dans P

I Algorithme polynomial pour co-A : algorithme pour A + inversion de la réponse

Est-ce que c’est vrai pour NP ?


La classe coNP

Co-problème du voyageur de commerce

donnée : ensemble de villes, entier k

question : est-ce qu’il n’existe aucun chemin passant par toutes les villes, et delongueur inférieure à k ?

Quel est le certificat ?

Un chemin qui ne passe pas par toutes les villes, ou de longueur > k ? pas suffisant !

Lister tous les chemins ? pas polynomial !

Le co-problème du voyageur de commerce ne semble pas avoir de certificat polynomial

Les complémentaires de certain problèmes dans NP ne semblent pas être dans NP


La classe coNP

Le complémentaire de certain problèmes dans NP ne semblent pas être dans NP

coNPEnsemble des problèmes de décision dont le problème complément est dans NP

ConjectureNP 6= coNP ?


Inclusion dans P-SPACE

Soit un algorithme non-déterministe en O(nc) temps, et donc mémoire.

il existe un algorithme déterministe qui n’utilise pas plus d’espace :

I Le certificat nécessite un espace fini (vérifiable en O(nc ) pour une donnée de taille n)

I Il y a donc un nombre fini de certificat : O(2nc)

I On génère et verifie tous les certificats (en temps O(nc2nc))

ThéorèmeNP ⊆ P-SPACE et coNP ⊆ P-SPACE


Résumé : les classes de complexité

P

(log n)-TIME

n-TIME

...

...

NP

coNP

P-SPACE

EXP-TIME


algorithmique et complexité algorithmes gloutons

Documents