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

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

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

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ée

et 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

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

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

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

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

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

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))

Algorithmes Récursifs 4 / 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))

Algorithmes Récursifs 4 / 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))

Algorithmes Récursifs 4 / 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))

Algorithmes Récursifs 4 / 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))

Algorithmes Récursifs 4 / 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))

Algorithmes Récursifs 4 / 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))

Algorithmes Récursifs 4 / 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))

Algorithmes Récursifs 4 / 31

Règles de calculs : combinaison des complexité

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

Algorithmes Récursifs 5 / 31

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)))

Algorithmes Récursifs 5 / 31

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 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))

Algorithmes Récursifs 5 / 31

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

Algorithmes Récursifs 6 / 31

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

Algorithmes Récursifs 6 / 31

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

Algorithmes Récursifs 6 / 31

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

Algorithmes Récursifs 6 / 31

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)

Algorithmes Récursifs 7 / 31

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)

Algorithmes Récursifs 7 / 31

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)

Algorithmes Récursifs 7 / 31

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)

Algorithmes Récursifs 7 / 31

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)

Algorithmes Récursifs 7 / 31

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)

Algorithmes Récursifs 7 / 31

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

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

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

Algorithmes Récursifs 8 / 31

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

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

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

Algorithmes Récursifs 8 / 31

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

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

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

Algorithmes Récursifs 8 / 31

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

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

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

Algorithmes Récursifs 8 / 31

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

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

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

Algorithmes Récursifs 8 / 31

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

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

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

Algorithmes Récursifs 8 / 31

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

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

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

Algorithmes Récursifs 8 / 31

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

Algorithmes Récursifs 9 / 31

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

Algorithmes Récursifs 9 / 31

Illustration du Tri Fusion

Algorithmes Récursifs 10 / 31

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)

Algorithmes Récursifs 11 / 31

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)

Algorithmes Récursifs 11 / 31

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)

Algorithmes Récursifs 11 / 31

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)

Algorithmes Récursifs 11 / 31

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

Algorithmes Récursifs 12 / 31

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

Algorithmes Récursifs 12 / 31

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

Algorithmes Récursifs 12 / 31

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

Algorithmes Récursifs 12 / 31

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

Algorithmes Récursifs 13 / 31

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

Algorithmes Récursifs 13 / 31

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

Algorithmes Récursifs 13 / 31

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

Algorithmes Récursifs 13 / 31

Méthode par substitution (condition aux limites)

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.

Algorithmes Récursifs 14 / 31

Méthode par substitution (condition aux limites)

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.

Algorithmes Récursifs 14 / 31

Méthode par substitution (condition aux limites)

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.

Algorithmes Récursifs 14 / 31

Méthode par substitution (condition aux limites)

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.

Algorithmes Récursifs 14 / 31

Méthode par substitution (condition aux limites)

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.

Algorithmes Récursifs 14 / 31

Méthode par substitution (condition aux limites)

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.

Algorithmes Récursifs 14 / 31

Méthode par substitution (condition aux limites)

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.

Algorithmes Récursifs 14 / 31

Méthode par substitution (condition aux limites)

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.

Algorithmes Récursifs 14 / 31

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))

Algorithmes Récursifs 15 / 31

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))

Algorithmes Récursifs 15 / 31

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))

Algorithmes Récursifs 15 / 31

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))

Algorithmes Récursifs 15 / 31

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))

Algorithmes Récursifs 15 / 31

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))

Algorithmes Récursifs 15 / 31

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))

Algorithmes Récursifs 15 / 31

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))

Algorithmes Récursifs 15 / 31

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

Algorithmes Récursifs 16 / 31

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

Algorithmes Récursifs 16 / 31

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

Algorithmes Récursifs 16 / 31

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

Algorithmes Récursifs 16 / 31

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

Algorithmes Récursifs 16 / 31

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)

Algorithmes Récursifs 17 / 31

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)

Algorithmes Récursifs 17 / 31

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)

Algorithmes Récursifs 17 / 31

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)

Algorithmes Récursifs 17 / 31

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)

Algorithmes Récursifs 17 / 31

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)

Algorithmes Récursifs 17 / 31

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)

Algorithmes Récursifs 17 / 31

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)

Algorithmes Récursifs 17 / 31

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

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)

Algorithmes Récursifs 18 / 31

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

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)

Algorithmes Récursifs 18 / 31

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

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)

Algorithmes Récursifs 18 / 31

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

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)

Algorithmes Récursifs 18 / 31

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

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)

Algorithmes Récursifs 18 / 31

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

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)

Algorithmes Récursifs 18 / 31

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 20 / 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 20 / 31

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 !)

Taille de la Donnée 21 / 31

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 !)

Taille de la Donnée 21 / 31

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 !)

Taille de la Donnée 21 / 31

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 !)

Taille de la Donnée 21 / 31

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 !)

Taille de la Donnée 21 / 31

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 !)

Taille de la Donnée 21 / 31

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)

Taille de la Donnée 22 / 31

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éments

Il 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)

Taille de la Donnée 22 / 31

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)

Taille de la Donnée 22 / 31

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)

Taille de la Donnée 22 / 31

La taille d’une structures de données

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 |)

Taille de la Donnée 23 / 31

La taille d’une structures de données

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 |)

Taille de la Donnée 23 / 31

La taille de la donnée

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)

Taille de la Donnée 24 / 31

La taille de la donnée

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)

Taille de la Donnée 24 / 31

La taille de la donnée

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)

Taille de la Donnée 24 / 31

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

Classes de Problèmes 26 / 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

Classes de Problèmes 26 / 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

Classes de Problèmes 26 / 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

Classes de Problèmes 26 / 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

Classes de Problèmes 26 / 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

Classes de Problèmes 26 / 31

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é

Classes de Problèmes 27 / 31

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é

Classes de Problèmes 27 / 31

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é

Classes de Problèmes 27 / 31

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é

Classes de Problèmes 27 / 31

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é

Classes de Problèmes 27 / 31

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é

Classes de Problèmes 27 / 31

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)

Classes de Problèmes 28 / 31

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)

Classes de Problèmes 28 / 31

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)

Classes de Problèmes 28 / 31

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)

Classes de Problèmes 28 / 31

Parcours de Graham

Trouver l’enveloppe convexe d’unensemble de points

Algorithme1 Trouver le point p de plus petite

ordonnée

O(n)

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

3 Appliquer le parcours de Graham

O(n)

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

a

b

c

d

e

f

g

h

i

j

k

3

4

5

8

1

6

9

7

2

10

Classes de Problèmes 29 / 31

Parcours de Graham

Trouver l’enveloppe convexe d’unensemble de points

Algorithme1 Trouver le point p de plus petite

ordonnée

O(n)

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

3 Appliquer le parcours de Graham

O(n)

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

a

b

c

d

e

f

g

h

i

j

k

3

4

5

8

1

6

9

7

2

10

Classes de Problèmes 29 / 31

Parcours de Graham

Trouver l’enveloppe convexe d’unensemble de points

Algorithme1 Trouver le point p de plus petite

ordonnée

O(n)

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

3 Appliquer le parcours de Graham

O(n)

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

a

b

c

d

e

f

g

h

i

j

k

3

4

5

8

1

6

9

7

2

10

Classes de Problèmes 29 / 31

Parcours de Graham

Trouver l’enveloppe convexe d’unensemble de points

Algorithme1 Trouver le point p de plus petite

ordonnée

O(n)

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

3 Appliquer le parcours de Graham

O(n)

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

b

c

d

e

f

g

h

i

j

k

3

4

5

8

1

6

9

7

2

10

Classes de Problèmes 29 / 31

Parcours de Graham

Trouver l’enveloppe convexe d’unensemble de points

Algorithme1 Trouver le point p de plus petite

ordonnée

O(n)

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

3 Appliquer le parcours de Graham

O(n)

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

b

c

d

e

f

g

h

i

j

k

3

4

5

8

1

6

9

7

2

10

Classes de Problèmes 29 / 31

Parcours de Graham

Trouver l’enveloppe convexe d’unensemble de points

Algorithme1 Trouver le point p de plus petite

ordonnée

O(n)

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

3 Appliquer le parcours de Graham

O(n)

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

b

c

d

e

f

g

h

i

j

k

3

4

5

8

1

6

9

7

2

10

Classes de Problèmes 29 / 31

Parcours de Graham

Trouver l’enveloppe convexe d’unensemble de points

Algorithme1 Trouver le point p de plus petite

ordonnée

O(n)

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

3 Appliquer le parcours de Graham

O(n)

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

b

c

d

e

f

g

h

i

j

k

3

4

5

8

1

6

9

7

2

10

Classes de Problèmes 29 / 31

Parcours de Graham

Trouver l’enveloppe convexe d’unensemble de points

Algorithme1 Trouver le point p de plus petite

ordonnée

O(n)

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

3 Appliquer le parcours de Graham

O(n)

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

a

b

c

d

e

f

g

h

i

j

k

3

4

5

8

1

6

9

7

2

10

Classes de Problèmes 29 / 31

Parcours de Graham

Trouver l’enveloppe convexe d’unensemble de points

Algorithme1 Trouver le point p de plus petite

ordonnée

O(n)

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

3 Appliquer le parcours de Graham

O(n)

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

a

b

c

d

e

f

g

h

i

j

k

3

4

5

8

1

6

9

7

2

10

Classes de Problèmes 29 / 31

Parcours de Graham

Trouver l’enveloppe convexe d’unensemble de points

Algorithme1 Trouver le point p de plus petite

ordonnée

O(n)

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

3 Appliquer le parcours de Graham

O(n)

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

a

b

c

d

e

f

g

h

i

j

k

3

4

5

8

1

6

9

7

2

10

Classes de Problèmes 29 / 31

Parcours de Graham

Trouver l’enveloppe convexe d’unensemble de points

Algorithme1 Trouver le point p de plus petite

ordonnée

O(n)

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

3 Appliquer le parcours de Graham

O(n)

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

a

b

c

d

e

f

g

h

i

j

k

3

4

5

8

1

6

9

7

2

10

Classes de Problèmes 29 / 31

Parcours de Graham

Trouver l’enveloppe convexe d’unensemble de points

Algorithme1 Trouver le point p de plus petite

ordonnée O(n)

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

3 Appliquer le parcours de Graham O(n)

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

a

b

c

d

e

f

g

h

i

j

k

3

4

5

8

1

6

9

7

2

10

Classes de Problèmes 29 / 31

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)

Classes de Problèmes 31 / 31

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)

Classes de Problèmes 31 / 31

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 Tri

I 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)

Classes de Problèmes 31 / 31

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)

Classes de Problèmes 31 / 31

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)

Classes de Problèmes 31 / 31