Rappelhomepages.laas.fr/ehebrard/papers/CM2.pdfRappel Problématique...

Rappel

ProblématiqueOn veut mesurer l’efficacité temporelle d’un algorithme.

Temps d’exécutionproportionnel au nombre d’opérations élementaires effectués.

Nombre d’opérations dépend de la taille de la donnéeet de la difficulté de l’instance ;

En général, on mesure la complexité asymptotique et dans le pire cas (notationsΩ,O,Θ).

1 / 31

Rappel

1 / 31

Rappel

1 / 31

Rappel

Nombre d’opérations dépend de la taille de la donnée

et de la difficulté de l’instance ;

1 / 31

Rappel

1 / 31

Rappel

1 / 31

Programme d’aujourd’hui

Règles de réduction pour Ω,O,Θ

Technique de calcul de complexité pour les récurrencesI Méthode par substitutionI Théorème Maître

Taille de la donnée

Vers une définition de classes de complexitéI En fonction du temps, de l’espace mémoireI Réduction polynômiale

2 / 31

Algorithmes Récursifs

Algorithmes Récursifs 3 / 31

Règles de calculs : combinaisons des complexités

Les instructions de base prennent un temps constant, noté O(1) ;

On additionne les complexités d’opérations en séquence :

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

Même chose pour les branchements conditionnels :

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

Exemple

si <condition> alors#instructions (1);

sinon#instructions (2);

O(g(n))O(f1(n))

O(f2(n))

= O(g(n) + f1(n) + f2(n))

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

Exemple

O(g(n))O(f1(n))

O(f2(n))

= O(g(n) + f1(n) + f2(n))

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

Exemple

O(g(n))O(f1(n))

O(f2(n))

= O(g(n) + f1(n) + f2(n))

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

Exemple

O(g(n))O(f1(n))

O(f2(n))

= O(g(n) + f1(n) + f2(n))

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

Exemple

O(g(n))

O(f1(n))

O(f2(n))

= O(g(n) + f1(n) + f2(n))

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

Exemple

O(g(n))O(f1(n))

O(f2(n))

= O(g(n) + f1(n) + f2(n))

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

Exemple

O(g(n))O(f1(n))

O(f2(n))

= O(g(n) + f1(n) + f2(n))

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

Exemple

O(g(n))O(f1(n))

O(f2(n))

= O(g(n) + f1(n) + f2(n))

Règles de calculs : combinaison des complexité

Dans les boucles, on multiplie la complexité du corps de la boucle par le nombred’itérations ;

Calcul de la complexité d’une boucle while :

Exempleen supposant qu’on a O(h(n)) itérationstant que <condition>faire

#instructions ;

O(g(n))O(f (n))

= O(h(n)× (g(n) + f (n)))

Calcul de la complexité d’une boucle for :

Exemple

en supposant qu’on a m itérations

pour i allant de a à b faire#instructions ; O(f (n))

= O((b − a + 1)× f (n))

Calcul de la complexité asymptotique d’unalgorithme

Pour calculer la complexité d’un algorithme :

1 on calcule la complexité de chaque “partie” de l’algorithme ;

2 on combine ces complexités conformément aux règles qu’on vient de voir ;

3 on simplifie le résultat grâce aux règles de simplifications qu’on a vues ;F élimination des constantes, etF conservation du (des) termes dominants

Exemple : calcul de la factorielle de n ∈ N

Reprenons le calcul de la factorielle, qui nécessitait 3n opérations :

Algorithme : Factorielle(n)Données : un entier nRésultat : un entier valant n!

1 fact, i : entier;2 début3 fact ← 2;4 pour i allant de 3 à n faire5 fact ← fact ∗ i ;6 retourner fact;

nombre coût

initialisation : Θ(1)× Θ(1)itérations : Θ(n)× Θ(1)mult. + affect. : Θ(n)× Θ(1)retour fonction : Θ(1)× Θ(1)

Nombre total d’opérations :

Θ(1) + Θ(n) ∗Θ(1) + Θ(n) ∗Θ(1) + Θ(1) = Θ(n)

nombre coût

initialisation : Θ(1)× Θ(1)

itérations : Θ(n)× Θ(1)mult. + affect. : Θ(n)× Θ(1)retour fonction : Θ(1)× Θ(1)

Θ(1) + Θ(n) ∗Θ(1) + Θ(n) ∗Θ(1) + Θ(1) = Θ(n)

nombre coût

initialisation : Θ(1)× Θ(1)itérations : Θ(n)× Θ(1)

mult. + affect. : Θ(n)× Θ(1)retour fonction : Θ(1)× Θ(1)

Θ(1) + Θ(n) ∗Θ(1) + Θ(n) ∗Θ(1) + Θ(1) = Θ(n)

nombre coût

initialisation : Θ(1)× Θ(1)itérations : Θ(n)× Θ(1)mult. + affect. : Θ(n)× Θ(1)

retour fonction : Θ(1)× Θ(1)

Θ(1) + Θ(n) ∗Θ(1) + Θ(n) ∗Θ(1) + Θ(1) = Θ(n)

nombre coût

Θ(1) + Θ(n) ∗Θ(1) + Θ(n) ∗Θ(1) + Θ(1) = Θ(n)

nombre coût

Θ(1) + Θ(n) ∗Θ(1) + Θ(n) ∗Θ(1) + Θ(1) = Θ(n)

Exemple : Tri à bulles

La méthode de “comptage” n’est pas toujours applicable directement

Algorithme : TriBulles(T )

Données : un tableau TRésultat : le tableau T trié

1 début2 pour i allant de 2 à |T | faire3 pour j allant de 1 à i − 1 faire4 si T [j + 1] < T [j] alors5 échanger(T [j + 1],T [j]);

nombre coût

itérations : Θ(|T |)× Θ(1)itération : ?× Θ(1)1ère itération : 1 comparaison2ème itération : 2 comparaisons. . .

Séries arithmétiquesn∑

k = 1 + 2 + 3 + · · ·+ n =12n(n + 1) ∈ Θ(n2)

Nombre total d’opérations : Θ(|T |2)

nombre coût

k = 1 + 2 + 3 + · · ·+ n =12n(n + 1) ∈ Θ(n2)

nombre coût

itérations : Θ(|T |)× Θ(1)

itération : ?× Θ(1)1ère itération : 1 comparaison2ème itération : 2 comparaisons. . .

k = 1 + 2 + 3 + · · ·+ n =12n(n + 1) ∈ Θ(n2)

nombre coût

itérations : Θ(|T |)× Θ(1)itération : ?× Θ(1)

1ère itération : 1 comparaison2ème itération : 2 comparaisons. . .

k = 1 + 2 + 3 + · · ·+ n =12n(n + 1) ∈ Θ(n2)

nombre coût

k = 1 + 2 + 3 + · · ·+ n =12n(n + 1) ∈ Θ(n2)

nombre coût

k = 1 + 2 + 3 + · · ·+ n =12n(n + 1) ∈ Θ(n2)

nombre coût

k = 1 + 2 + 3 + · · ·+ n =12n(n + 1) ∈ Θ(n2)

Récurrences

Stratégie “diviser pour régner”

Algorithme : TriFusion(T )

Données : un tableau TRésultat : le tableau T triémil : entier;début

si |T | ≤ 1 alorsretourner T ;

sinonmilieu ← b |T |+1

2 c;retournerFusion(T [:mil ] , T [mil :]);

Algorithme : Fusion(T1,T2)Données : deux tableaux T1 et T2Résultat : un tableau T trié contenant les

éléments de T1 et de T2T : tableau de taille T1 + T2;début

si |T1| = 0 alorsT ← T2;

sinon si |T2| = 0 alorsT ← T1;

sinon si T1[1] < T2[1] alorsT [1]← T1[1];T [2:]← Fusion(T1[2:],T2[1:]);

sinonT [1]← T2[1];T [2:]← Fusion(T1[1:],T2[2:]);

retourner T

Récurrences

Stratégie “diviser pour régner”

Algorithme : TriFusion(T )

Données : un tableau TRésultat : le tableau T triémil : entier;début

si |T | ≤ 1 alorsretourner T ;

sinonmilieu ← b |T |+1

2 c;retournerFusion(T [:mil ] , T [mil :]);

Algorithme : Fusion(T1,T2)Données : deux tableaux T1 et T2Résultat : un tableau T trié contenant les

éléments de T1 et de T2T : tableau de taille T1 + T2;début

si |T1| = 0 alorsT ← T2;

sinon si |T2| = 0 alorsT ← T1;

sinon si T1[1] < T2[1] alorsT [1]← T1[1];T [2:]← Fusion(T1[2:],T2[1:]);

sinonT [1]← T2[1];T [2:]← Fusion(T1[1:],T2[2:]);

retourner T

Illustration du Tri Fusion

Récurrences

Temps d’exécution T dans le pire des cas du tri fusion pour trier un tableau de nentiers

T (n) =

Θ(1) si n = 12T (n/2) + Θ(n) si n > 1

Complexité du tri fusion : T (n) = Θ(n log n)

Comment passer de l’un à l’autre ?I Méthode par substitutionI Méthode générale (théorème maître)

Récurrences

T (n) =

Θ(1) si n = 12T (n/2) + Θ(n) si n > 1

Récurrences

T (n) =

Θ(1) si n = 12T (n/2) + Θ(n) si n > 1

Récurrences

T (n) =

Θ(1) si n = 12T (n/2) + Θ(n) si n > 1

Méthode par substitution

Il faut avoir une intuition sur la forme de la solution (ici : O(n log n))

On veut montrer que T (n) = 2T (bn/2c) + Θ(n) ∈ O(n log n)

On montre par induction qu’il existe f (n) t.q. ∀n T (n) ≤ f (n)

I On va en déduire a posteriori que T (n) ∈ O(f (n))

Attention !L’hypothèse d’induction est T (n) ≤ f (n), et non T (n) ∈ O(f (n))

L’argument inductif “pour tout x < n, T (x) ∈ O(f (x))” ne veut pas dire grand chosepuisque la notation O est définie pour n arbitrairement grand : on remplace tous lestermes en O,Ω,Θ par une fonction élément de l’ensemble

Méthode par substitution (condition aux limites)

T (n) = 2T (bn/2c) + n ≤ cn log n

Il faut montrer que la formule est vraie pour les conditions limites de la récurrencepour des données de petite taille, i.e. n = 1

Problème : c’est faux pour n = 1 car c × 1× log 1 = 0 < T (1) = 1 ;

Mais on cherche à montrer la complexité pour des données de grande taille : n ≥ n0

et on a le choix pour n0 =⇒ vérifier pour T (2) (et T (3))

On peut aussi borner par f (n) = cn log n + b puisque cn log n + b ∈ O(n log n)

I Ou même f (n) = cn log n + an + b

T (n) = 2T (bn/2c) + n ≤ cn log n

On vérifie que la formule tient pour T (2) et T (3)

T (2) = 2T (b2/2c) + 2

T (2) = 2T (1) + 2

T (2) = 2 ∗ 1 + 2 = 4 ≤ 2c log 2 = 2c

T (2) = 4 ≤ 2c

c ≥ 2

On fait la même chose pour T (3)...

... et on obtient que c doit être ≥ 2.

T (n) = 2T (bn/2c) + n ≤ cn log n

T (2) = 2T (b2/2c) + 2

T (2) = 2T (1) + 2

T (2) = 2 ∗ 1 + 2 = 4 ≤ 2c log 2 = 2c

T (2) = 4 ≤ 2c

c ≥ 2

T (n) = 2T (bn/2c) + n ≤ cn log n

T (2) = 2T (b2/2c) + 2

T (2) = 2T (1) + 2

T (2) = 2 ∗ 1 + 2 = 4 ≤ 2c log 2 = 2c

T (2) = 4 ≤ 2c

c ≥ 2

T (n) = 2T (bn/2c) + n ≤ cn log n

T (2) = 2T (b2/2c) + 2

T (2) = 2T (1) + 2

T (2) = 2 ∗ 1 + 2 = 4 ≤ 2c log 2 = 2c

T (2) = 4 ≤ 2c

c ≥ 2

T (n) = 2T (bn/2c) + n ≤ cn log n

T (2) = 2T (b2/2c) + 2

T (2) = 2T (1) + 2

T (2) = 2 ∗ 1 + 2 = 4 ≤ 2c log 2 = 2c

T (2) = 4 ≤ 2c

c ≥ 2

T (n) = 2T (bn/2c) + n ≤ cn log n

T (2) = 2T (b2/2c) + 2

T (2) = 2T (1) + 2

T (2) = 2 ∗ 1 + 2 = 4 ≤ 2c log 2 = 2c

T (2) = 4 ≤ 2c

c ≥ 2

T (n) = 2T (bn/2c) + n ≤ cn log n

T (2) = 2T (b2/2c) + 2

T (2) = 2T (1) + 2

T (2) = 2 ∗ 1 + 2 = 4 ≤ 2c log 2 = 2c

T (2) = 4 ≤ 2c

c ≥ 2

T (n) = 2T (bn/2c) + n ≤ cn log n

T (2) = 2T (b2/2c) + 2

T (2) = 2T (1) + 2

T (2) = 2 ∗ 1 + 2 = 4 ≤ 2c log 2 = 2c

T (2) = 4 ≤ 2c

c ≥ 2

Méthode par substitution (Induction)

T (n) = 2T (bn/2c) + n ≤ cn log n

On suppose maintenant que T (x) ≤ cx log x est vrai pour tout 2 ≤ x ≤ n − 1 ; et onvérifie que c’est aussi le cas pour x = n

T (bn/2c) ≤ cbn/2c logbn/2c

On substitue dans l’expression

T (n) = 2T (bn/2c) + n≤ 2cb n2c log(b n2c) + n≤ cn log(n/2) + n= cn log n − cn log 2 + n= cn log n − cn + n≤ cn log n

A condition que c ≥ 1 (on prendra c ≥ 2, à cause de T (2) et T (3))

T (n) = 2T (bn/2c) + n ≤ cn log n

T (n) = 2T (bn/2c) + n

≤ 2cb n2c log(b n2c) + n≤ cn log(n/2) + n= cn log n − cn log 2 + n= cn log n − cn + n≤ cn log n

T (n) = 2T (bn/2c) + n ≤ cn log n

T (n) = 2T (bn/2c) + n≤ 2cb n2c log(b n2c) + n

≤ cn log(n/2) + n= cn log n − cn log 2 + n= cn log n − cn + n≤ cn log n

T (n) = 2T (bn/2c) + n ≤ cn log n

T (n) = 2T (bn/2c) + n≤ 2cb n2c log(b n2c) + n≤ cn log(n/2) + n

= cn log n − cn log 2 + n= cn log n − cn + n≤ cn log n

T (n) = 2T (bn/2c) + n ≤ cn log n

T (n) = 2T (bn/2c) + n≤ 2cb n2c log(b n2c) + n≤ cn log(n/2) + n= cn log n − cn log 2 + n

= cn log n − cn + n≤ cn log n

T (n) = 2T (bn/2c) + n ≤ cn log n

T (n) = 2T (bn/2c) + n≤ 2cb n2c log(b n2c) + n≤ cn log(n/2) + n= cn log n − cn log 2 + n= cn log n − cn + n

≤ cn log n

T (n) = 2T (bn/2c) + n ≤ cn log n

Méthode générale

Pour les récurrence de la forme T (n) = aT (n/b) + f (n) avec a ≥ 1 et b > 1

L’algorithme découpe la donnée en a sous-problèmes de taille n/b et les résoutrécursivementLa fonction f représente le coût de division et de « fusion » du problème.

Exemple pour le tri fusion : a = 2, b = 2 et f (n) = Θ(n)

Exemple pour la recherche binaire : a = 1, b = 2 et f (n) = Θ(1)

Il existe un théorème pour calculer la complexité : le théorème maître

Méthode générale

Théorème maître (général) - version simplifiée

On ne considère que les récurrences T (n) = aT (n/b) + Θ(nd) (ou O(nd))avec a ≥ 1, b > 1, d ≥ 0

1 Si d > logb a,T (n) = Θ(nd ) complexité dominée par le coût de fusion2 Si d < logb a,T (n) = Θ(nlogb a) complexité dominée par le coût du sous-problème3 Si d = logb a,T (n) = Θ(nd log n) pas de domination

Tri fusion :

T (n) =

Θ(1) si n = 12T (n/2) + Θ(n) si n > 1

a = 2, b = 2, d = 1, log2 2 = 1 = d

On est donc dans le cas 3 et la complexité en Θ(n log n)

Tri fusion :

T (n) =

Θ(1) si n = 12T (n/2) + Θ(n) si n > 1

a = 2, b = 2, d = 1, log2 2 = 1 = d

Tri fusion :

T (n) =

Θ(1) si n = 12T (n/2) + Θ(n) si n > 1

a = 2, b = 2, d = 1, log2 2 = 1 = d

Tri fusion :

T (n) =

Θ(1) si n = 12T (n/2) + Θ(n) si n > 1

a = 2,

b = 2, d = 1, log2 2 = 1 = d

Tri fusion :

T (n) =

Θ(1) si n = 12T (n/2) + Θ(n) si n > 1

a = 2, b = 2,

d = 1, log2 2 = 1 = d

Tri fusion :

T (n) =

Θ(1) si n = 12T (n/2) + Θ(n) si n > 1

a = 2, b = 2, d = 1,

log2 2 = 1 = d

Tri fusion :

T (n) =

Θ(1) si n = 12T (n/2) + Θ(n) si n > 1

a = 2, b = 2, d = 1, log2 2 = 1 = d

Tri fusion :

T (n) =

Θ(1) si n = 12T (n/2) + Θ(n) si n > 1

a = 2, b = 2, d = 1, log2 2 = 1 = d

Recherche binaire :

T (n) =

Θ(1) si n = 1T (n/2) + Θ(1) si n > 1

a = 1, b = 2, d = 0, log2 1 = 0 = d

On est donc dans le cas 3 et la complexité en Θ(log n)

Recherche binaire :

T (n) =

Θ(1) si n = 1T (n/2) + Θ(1) si n > 1

a = 1,

b = 2, d = 0, log2 1 = 0 = d

Recherche binaire :

T (n) =

Θ(1) si n = 1T (n/2) + Θ(1) si n > 1

a = 1, b = 2,

d = 0, log2 1 = 0 = d

Recherche binaire :

T (n) =

Θ(1) si n = 1T (n/2) + Θ(1) si n > 1

a = 1, b = 2, d = 0,

log2 1 = 0 = d

Recherche binaire :

T (n) =

Θ(1) si n = 1T (n/2) + Θ(1) si n > 1

a = 1, b = 2, d = 0, log2 1 = 0 = d

Recherche binaire :

T (n) =

Θ(1) si n = 1T (n/2) + Θ(1) si n > 1

a = 1, b = 2, d = 0, log2 1 = 0 = d

Taille de la Donnée

Taille de la Donnée 19 / 31

La taille de la donnée

Taille de la donnée |x |Espace mémoire nécessaire pour la représenter x

Dans une unité quelconque, fonction de la donnée : |x | ∈ Θ(f (x))

Type primitif entier, flottant, etc. sur 32 ou 64 bits : Θ(1)

Entier non-borné x : |x | ∈ Θ(log x)

Liste L de n caractères : |L| ∈ Θ(n)

Taille de la donnée |x |Espace mémoire nécessaire pour la représenter x

Dans une unité quelconque, fonction de la donnée : |x | ∈ Θ(f (x))

Type primitif entier, flottant, etc. sur 32 ou 64 bits : Θ(1)

Entier non-borné x : |x | ∈ Θ(log x)

Liste L de n caractères : |L| ∈ Θ(n)

La taille de la donnée : exemple

La complexité se mesure en fonction de la taille de la donnée

Parfois, on mesure plus facilement la complexité d’un algorithme en fonction d’unautre paramètre que la taille de la donnée (ex : sa valeur)

Si l’algorithme A est en Θ(f (x)) pour une donnée x et la taille |x | est en Θ(g(x)),alors la complexité de A sera 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)

Mais la taille de la donnée est |x | = Θ(log x)

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

cet algorithme est donc en Θ(22|x|)(exponentiel !)

Exemple

r : entier;début

retourner r ;

Exemple

r : entier;début

retourner r ;

Exemple

r : entier;début

retourner r ;

Exemple

r : entier;début

retourner r ;

Exemple

r : entier;début

retourner r ;

La taille d’une structures de données

Dans le cas de structures de données (listes, ensembles, etc.) il faut analyser lastructure : la taille de chaque élément, les pointeurs, etc.

Exemple, liste L de n élémentsIl faut Θ(1) bits par élément, plus la somme des tailles des éléments : donc|L| ∈ Θ(n) +

∑e∈ |e| ⊆ Θ(n)×Θ(|e|)

Les éléments sont des entiers : |L| ∈ Θ(n)

Les éléments sont des entiers non bornés et m est l’élément maximum :|L| ∈ Θ(n logm)

Exemple, liste L de n éléments

Il faut Θ(1) bits par élément, plus la somme des tailles des éléments : donc|L| ∈ Θ(n) +

∑e∈ |e| ⊆ Θ(n)×Θ(|e|)

La taille des structures va dépendre de leur codage :

Exemple, graphe G = (S ,A)

Tableau de tableaux : Il faut Θ(1) bits par arc potentiel, donc|G | ∈ Θ(|S |2)

Listes d’adjacence : Il faut Θ(log |S |) bits par arc dans A, donc|G | ∈ Θ(|A| log |S |)

La taille des structures va dépendre de leur codage :

Exemple, graphe G = (S ,A)

Tableau de tableaux : Il faut Θ(1) bits par arc potentiel, donc|G | ∈ Θ(|S |2)

Listes d’adjacence : Il faut Θ(log |S |) bits par arc dans A, donc|G | ∈ Θ(|A| log |S |)

Attention : sujet piégeux !

Taille d’une liste de n entiers (codés sur 32 bits) : Θ(n)

Taille d’une liste de n entiers (où l’élément maximum est m) : Θ(n logm)

Taille d’un ensemble de n entiers (codés sur 32 bits) : Θ(1) ! !I Il y a un nombre fini d’entiers représentable avec 32 bits (232), et donc un nombre fini

d’ensembles de tels entiers (2232)

Classes de Problèmes

Classes de Problèmes 25 / 31

Vocabulaire

Un algorithme est dit :

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

linéaire (resp. linéairement borné) si sa complexité (dans le pire des cas) est Θ(n)(resp. O(n))

quadratique (resp. au plus quadratique) si sa complexité (dans le pire des cas) estΘ(n2) (resp. O(n2))

polynômial ou polynômialement borné, si sa complexité (dans le pire des cas) est enO(np) pour un certain p > 0

(au plus) exponentiel si elle est en O(2nc

) pour un certain c > 0

Vocabulaire

Classes de problèmes

Analyser la complexité des algorithmes permet de faire un choix éclairé

, mais passeulement

Classer les problèmesI en fonction de la complexité du meilleur algorithme connu pour les résoudre

TIME (f (n))

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

Tri ∈ TIME(n log n)

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

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

Trier est plus “difficile” que chercher dans un tableau trié

Analyser la complexité des algorithmes permet de faire un choix éclairé, mais passeulement

TIME (f (n))

Classes de problèmes (suite)

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

SPACE (f (n))

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

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

ThéorèmeTIME(f (n)) ⊆ SPACE(f (n))

Problème A ∈ TIME(f (n)) =⇒ A ∈ SPACE(f (n))

Chaque octet utilisé implique Ω(1) opération(s)

SPACE (f (n))

Parcours de Graham

Trouver l’enveloppe convexe d’unensemble de points

Algorithme1 Trouver le point p de plus petite

ordonnée

2 Trier les autres points en fonction del’angle avec l’axe des abcisses parrapport à p

3 Appliquer le parcours de Graham

I retour arrière en cas de “tournant àdroite”

Parcours de Graham

ordonnée

Parcours de Graham

ordonnée

Parcours de Graham

ordonnée

I retour arrière en cas de “tournant àdroite” a

Parcours de Graham

ordonnée

Parcours de Graham

ordonnée

Parcours de Graham

ordonnée

Parcours de Graham

ordonnée

Parcours de Graham

ordonnée

Parcours de Graham

ordonnée

Parcours de Graham

ordonnée

Parcours de Graham

ordonnée O(n)

3 Appliquer le parcours de Graham O(n)

Réduction polynômiale

On peut trouver l’enveloppe convexe en O(n) plus le coût de trier n entiers

Tri ∈ TIME(n log n) =⇒ Enveloppe convexe ∈ TIME(n log n)

Réduction de Enveloppe convexe vers Tri :I Enveloppe convexe pas plus difficile que TriI Tri au moins aussi difficile que Enveloppe convexe

Réduction polynômiale de A vers B (de Cook / de Turing) :

Un algorithme pour résoudre A en O(nc) (pour c un constante et n la taillede la donnée) sous l’hypothèse que le problème B peut être résolu en Θ(1)

Réduction de Enveloppe convexe vers Tri :I Enveloppe convexe pas plus difficile que Tri

I Tri au moins aussi difficile que Enveloppe convexe

Rappelhomepages.laas.fr/ehebrard/papers/CM2.pdfRappel Problématique...

Documents

Transcript of Rappelhomepages.laas.fr/ehebrard/papers/CM2.pdfRappel Problématique...