1 notations asymptotiques et complexité notations asymptotiques : 0 et complexité des algorithmes...
TRANSCRIPT
1
Notations Asymptotiques Et Complexité
Notations asymptotiques : 0 et
Complexité des algorithmesExemples de calcul de
complexité
2
Complexités d ’un algorithme
Un algorithme à partir d ’une donnée établit un résultat .
La taille de la donnée est mesurée par un entier n. complexité temporelle une
fonction de n qui mesure le temps de calcul pour une donnée de taille n
complexité en mémoire
3
Complexités temporelles
Dans le pire des cas : donne une borne sur le temps de calcul pour toute donnée de taille n
En moyenne : fait la moyenne des temps de calculs pour toutes les données de taille n
4
Mesure-t-on vraiment le temps de calcul ?
Non, car le temps de calcul dépend de la machine.
Mesures effectuées à une constante multiplicative près
Terme dominant
5
Définitions
On dit que f est du même ordre de grandeur que g et l'on note f = (g) lorsque f=O(g) et g=O(f).
On dit que f est dominée par g
(noté f= O (g)) lorsque
)()(,,0, 0 ncgnfnncnO
6
Définitions
f est négligeable devant g, (noté f =o(g)) lorsque f(n)/g(n) tend vers 0 quand n tend vers l'infini
On dit que f est équivalente à g lorsque f(n)/g(n) tend vers 1 lorsque n tend vers l'infini
7
Polynômes et notations O et
Soit P (n) un polynôme en n. Pour quelles valeurs de p a-t-on P(n)=O(np)? Pour quelles valeurs de p a-t-on P(n)=(np)?
8
Montrer que pour tout entier k, on a
1
0
( )n
k k
i
i n
9
Échelle De Comparaison
Exercice
Soient les fonctions
f1(n)=n, f2(n)=2n, f3(n)=n2, f4(n)=2n, f5(n)=nn, f6(n)=log n, f7(n)=n!, f8(n)= nlogn
Pour chaque couple i, j, dire si l’on a fi=o( fj),
fi=O( fj), fi=( fj).
10
109 Instructions/secondes
n 5 10 15 20 100 1000log n 3 10-9 s 4 10-9 s 4 10-9 s 5 10-9 s 7 10-9 s 10-8 s2n 10 10-9 s 2 10-8s 3 10-8 s 4 10-8 s 2 10-7 s 2 10-6 snlogn 12 10-9 s 3 10-8s 6 10-8s 10-7s 7 10-7s 10-5sn2 25 10-9 s 10-7 s 2,25 10-7 s 4 10-7 s 10-5 s 10-3 sn5 3 10-6 s 10-4 s 7,59 10-4 s 3 10-3 s 10 s 106 s
= 11 jours2n 32 10-9 s 10-6 s 3,28 10-5 s 10-3 s 1,2 1021 s
4 1011 siècles10292 s3 10282 siècles
n ! 120 10-9 s 4 10-3 s 1,4 103s=23 minutes
2,4 109 s =77 ans
10147 s3 10139 siècles
10 500 s
nn 3 10-6 s 10 s 4,37 108s =13 ans
1017s =3 107siècles
10191s3 10181siècles
10 3000 s
11
En Une Journée on Peut Aller Jusqu’à ?
f(n) n log n2n nlognn2 n5 2n n ! nn
N max9 10 13 1310.3104,5 10 13 2 10 1210 7 60032 16 12
12
Et En Un an ?
f(n)nlog n2nnlognn2 n5 2n n ! nn
N max31 10 15 16101015 10 155 10 141,7 10 82000551813
13
Pourquoi Utiliser O Et Pour Mesurer Des Complexités?Expressions à une constante
multiplicative près, indépendante du temps de calcul d ’une instruction de base
Toute instruction de base prend un temps un
Terme dominant uniquement donc expression simple
14
n, C’est quoi?
La complexité s’exprime en fonction de la taille de la donnée
A vous de dire quelle fonction taille vous avez choisie
Et la donnée c’est quoi ?
15
Règle 1 Composition Séquentielle
I1 complexité temporelle en (f1(n))
I2 complexité temporelle en (f2(n))
Le bloc d’instructions
I1 ;
I2
a une complexité temporelle en (max(f1 (n),f2 (n))
16
Règle 2 If Else
Évaluation de C est en (f(n)) De I1 en (f1 (n)), de I2 en (f2
(n))
Alors la complexité de l’instruction
if C I1 else I2 ;
est en O(max(f(n),f1 (n),f2 (n))
17
Règle 3 Boucle for
I1 a une complexité temporelle en (f1 (n))
I1 n’a aucun effet sur les variables i et n.
La complexité temporelle de la boucle
for (int i=1 ; i< = n ; i++){
I1
}
est en (n(f1 (n))
18
Si une instruction I se trouve au cœur de k boucles for imbriquées, chacune d'elle de la forme for (int i=1 ; i < n ; i++), combien de fois l'instruction I est elle exécutée ?
19
Si une instruction I se trouve au cœur de k boucles for imbriquées, chacune d'elle de la forme
for (int ij=1 ; ij < ij-1 ; i++), (avec i0=n), combien de fois l'instruction I est elle exécutée ?
20
Règle 4 Boucle While
Évaluation de C en (f1 (n))
I en (f2 (n))
Boucle while est exécutée (g(n))
while C {I}
est en (g(n)*max(f1 (n),f2 (n)))
21
Estimer les complexités des morceaux de codes suivants, sachant que et l’ instruction est en (1) et ne
modifie pas les entiers i, j, k et n
for (int i=1 ; i < n ; i++)
{ for (int j=i+1 ; j <=n ; j++)
{ for ( int k=1 ; k <=j ; k++)
{
I1
}
}
}
22
Estimer les complexités des morceaux de codes suivants, sachant que et les instructionsI1,I2,I3sont en (1) et ne modifie pas les entiers i, j, k et n
int i=1 ;int j =1 ;while (i <n) { i++ ; I1 ; while (( j < n) && Condition) { j++ ; I2 } ; I3 ; }
23
Règle 5 Composition De MéthodesMethode1 (classe1 c1) en O(f1
(taille1 (c1))
Methode2 ( classe2 c2) en O(f2 (taille2 (c2))
Methode2 renvoie un objet de classe1
La complexité de methode1 (methode2 ( c2))
est en O(max (f2 (taille2 (c2)) ,f1 (taille1 (méthode2 (c2))))
24
On connaît l'écriture d'un nombre en base b, et l'on veut convertir ce nombre en basse usuelle (10). 1. On utilise la méthode "direct". Quelle en est la complexité?
public int direct ( int[] a, int b){int résultat =a[0] ;int auxiliaire ;for (int rang= 1 ; rang < a.length ; rang++){ if (a[rang] != 0) { auxiliaire = a[rang] ; for (int indice =1 ; indice <=rang ; indice ++){
auxiliaire = auxiliaire *b ; }
résultat = résultat + auxiliaire;
} return résultat ; }
25
Prouvez que la méthode suivante dite de Horner, effectue bien le même travail. Quelle en est la complexité
public int horner ( int[] a, int b) {
int n = a.length ;
int résultat =a[n-1] ;
for (int rang = n-2 ; rang >= 0 ; rang--){
résultat = b* résultat +a[rang] ;
}
return résultat ;
}
26
On désire élever l'entier a à la puissance n.
Quelle est la complexité de la méthode suivante?
public int puissance (int n, int a) {
int résultat = a ;
for(int i =1 ; i <n ;i++){
résultat=résultat*a ;
}
return résultat ;
}
27
Montrez que le code suivant est correct. Quel en est la complexité ?
public int puissance (int n, int a) { int aux = n ; int puissancedea=a ; int résultat=1 ; while ( aux !=0) { if (aux mod 2 = = 1)
résultat =résultat * puissancedea ; aux=aux/2 ;
puissancedea = puissancedea *
puissancedea ;}return résultat ;
}
28
Programmation récursive
Quelques exemplesEquations de récurrencesQuelques méthodes de
résolution
29
Recherche dichotomique du plus grand élément
L contient N élémentsAlgorithme (récursif)
Si L contient un seul élément c ’est fini
Sinon : Couper L en deux listes L1 et L2 de
taille presque identiques Chercher m1 le max de L1
Chercher m2 le max de L1
Comparer m1 et m2
30
Combien de comparaisons ?
c(1)=0c(n) = c( n/2 )+c(n/2)+1
31
Déterminez la complexité de la méthode suivante
int factorial(int n)
{
if (n == 0) return 1;
else return (n*factorial(n-1));
}
32
Méthode factorielle
Soit c(n) la nombre de multiplications effectuées dans le calcul de factoriel(n).
On a c(n)=c(n-1)+1, c(1)=0
33
Recherche du maximum dans une table de n éléments
Si n=1, renvoyer l’unique élément
Sinon calculer recursivement le maximum des n-1 premiers élements. Le comparer avec le dernier élément, renvoyer le plus grand des deux.
34
Analyse : nombres de comparaisons effectuées
C(n)= complexité de la recherche du plus grand parmi n
c(n)=c(n-1)+1
c(1)=0
35
Trier une table de n éléments
Si n=1 rien à faireSinon
rechercher le maximum de la table
échanger le maximum et le dernier élément
trier la sous-table constituée des n-1 premiers éléments
36
c(n)=c(n-1)+an+b
c(1)=1
37
Tours de Hanoi
Combien de mouvements au minimum pour déplacer une tour de n disques
38
Tour de Hanoi
class Towers
{
static int nDisks=7;
public static void main(String[] args)
{moveTowers(nDisks,’A’,’B’,’C’);
}
39
public static void moveTowers
(int n, char from, char inter, char to)
{if (n==1)
System.out.println(“Disk 1 from”+from +”to”+to);
else {
moveTowers( n-1,from, to , inter);
System.out.println(“Disk” +n+”from”+from +”to”+to);
moveTowers( n-1,inter, from , to); }
}
}
40
Complexité de moveTowers
c(n)=2c(n-1)+k (ou c(n)=2c(n-1)+1)
Donc c(n)=a2n+b
C(n)=(2n)
41
On considère deux versions modifiées des tours de Hanoi. Dans chacun des cas, on demande quel est le nombre minimum de déplacements de disques nécessaires.
La pile contient initialement 2n disques, de n tailles différentes, il y a deux disques de chaque taille. Les disques de même taille sont indistinguables
La pile comporte n disques de tailles différentes, mais les 3 piquets sont sur un cercle et les mouvements doivent toujours se faire dans le sens des aiguilles d'une montre
42
Nombres De Fibonacci
public int fibonacci (int n) {
if (n= =0) return 0 ;
else
if (n= =1) return 1 ;
else return
fibonacci(n-1)+fibonacci(n-2) ;
}
43
Analyse de la complexité
c(n)=c(n-1)+c(n-2)+1c(1)=c(0)=1
44
Complexité d’une méthode récursive …...
…… résolution d’une équation de récurrence
Avec un outil de calcul formel (type maple)
Avec des théorèmes de maths
45
Récurrences linéaires
Définition:
Une relation de récurrence linéaire homogène d’ordre k , à coefficients constants est définie par une équation de la forme
Le polynôme caractéristique associé est
un a1un 1akun k (R )
P(r ) r k a1rk 1 ak 1r ak
46
Solutions d’une équation de récurrence linéaire d’ordre kL’ensemble des solutions
forme un espace vectoriel de dimension k
Si r est racine du polynôme caractèristique alors est solution de l’équation.
Cas des racines multiples
nn ru
47
Méthode du polynôme caractéristique
Soit E l’équation de récurrence .
Soient ri , les q racines du polynôme caractéristique de (E), ri ayant multiplicité mi.
Les solutions de (E) s’écrivent sous la forme
où les sont des polynômes en n de degré
mi-1.
nj
q
jj rnP )(
1
Pj(n)
48
Exemple
Détermine en fonction de u0 et u1, la suite telle que
un=un-1-2un-2
49
Réponse
u n u 0
2 i(
2 u 1 u 0
2 7)
r1
n u 0
2 i (
2 u 1 u 0
2 7)
r 2
n
r1 1 i 7
2r2
1 i 7
2
50
Exercice
Utilisez la méthode du polynôme caractèristique pour résoudre l’équation de récurrence
6
1
44
1
0
21
u
u
uuu nnn
51
Exercice
Chaque jour, pour mon goûter , je m’achète
ou ou
2F 2F 4F
Soit gn le nombre de choix de goûters possibles si l’on a n Francs
Déterminer g1,g2,g3 et g4
Déterminer et résoudre l’équation de récurrence liant les gn
52
Donnez l’ensemble des solutions des équations de récurrences suivantes :
un=2un-1-un-2
vn=vn-1+6vn-2
53
Déterminez la suite un , telle que des:
un=5un-1-8un-2+4un-3
u1=3, u2=11, u3=31
54
Equations non homogènes
Soit R l’équation non homogène
On lui associe l’équation homogène R’
La différence entre deux solutions de R’ est une solution de R
nk, un a1un 1akun k b(n)
nk, un a1un 1akun k
55
Espace affine/Espace vectoriel
Soit sn une solution particulière de R’.
Toute solution de R’ est obtenue à partir d’une solution de R en lui ajoutant sn
56
Une recette de cuisine
Si l’équation est de la forme
il existe une solution particulière de la forme
où Qi(n) est un polynôme de degré d(Pi)+mi
nk, un a1un 1akun k bin
i1
l
Pi(n)
bin
i1
l
Qi(n)
57
Exercices
un 2un 1 1, u0 0
un 2un 1 n 2n , u1 0
58
Donnez l’ensemble des solutions des équations de récurrences suivantes :
un=3un-1-2un-2+n
vn=vn-1+6vn-2+5n
wn=wn-1+6wn-2+3n
59
Résoudre l'équation de récurrence
un=3un-1-2un-2+n, u0=0, u1=0
60
Soit sommeFactoriel, la fonction définie par Evaluer la complexité en nombre de multiplications des méthodes récursives après
61
public int sommeFactoriel(int n)
{int factorieln ;
if (n<=1)
{return n+1 };
else
{
factorieln = n * (sommeFactoriel (n-1) – sommeFactoriel (n-2)) ;
return sommeFactoriel (n-1) + factorieln ;
}
}
62
public int sommeFactoriel(int n)
{int factorieln , somme ;
if (n<=1)
{ return n+1 };
else {somme = sommeFactoriel (n-1) ;
factorieln = n * (somme– sommeFactoriel (n-2)) ;
return somme + factorieln ;
}
}
63
public class DeuxEntiers {
int somme ;
int factoriel
}DeuxEntiers factorieletSommeFactoriel (int n)
{
DeuxEntiers resultat ;
if (n==0)
{
resultat.somme = 1 ;
resultat.factoriel = 1 ;
return resultat ;
} ;
else
64
{ resultat=factorieletSommeFactoriel (n-1) ;
resultat.factoriel = n* resultat.factoriel ;
resultat.somme = resultat.somme+ resultat.factoriel ;
return resultat ;
} ;
}
public int sommeFactoriel (int n)
{
DeuxEntiers resultat ;
resultat=factorieletSommeFactoriel (n) ;
return resultat.somme ;
}
65
Parmi les méthodes récursives vues en exemple quelles sont
celles dont on peut maintenant calculer la complexité?
FactorielleTriTours de HanoiLes nombres de FibonnacciMais pas la recherche
dichotomique
66
Le cas de Fibonacci
On obtient une complexité exponentielle pour la programmation récursive.
Il existe des programmations plus efficace du calcul du nième nombre de fibonacci.
67
Fibonacci V2
public int fibonacci (int n ){ int f0=0 ; int f1=1 ; for ( int i =2 ; i < n ; i++){ f1=f0+f1 ; // f1 est le ième terme de la suite f0 = f1-f0 ;
//f0 est le i-1 ième terme de la suite } ; // f1 est le nième terme de la suite
pour tout n >0 if (n==0) return 0 ; else return f1 ; }
68
Complexité de la V2
Cette fois la complexité est linéaire
69
Méthode Rapide
On utilise une autre relation d ’induction
On décompose n en base 2
La suite d0=1, di=2di1+decomposition(p-i), est telle que dp=n. On calcul les fdi.
1112
21
22
)2(
kkkk
kkk
FFFF
FFF
ip
i
ionecompositidn 2][1
0
70
Calcul Des Nombres De Fibonacci V3
public int [] decompose (int n) {
int p =log2 n ;
int auxiliaire = n ;
int[p] decomposition ;
for (int indice = 0 ; indice <p, indice ++) {
decomposition[indice] = auxiliaire mod 2 ;
auxiliaire = auxiliaire / 2;
}
return decomposition ;
}
71
Calcul Des Nombres De Fibonacci V3
public int fibonacci (int n) {
int a =0 ;int b =1 ;int p = log2 n ; int auxiliaire ;
int [p] decomposition = decompose (n) ;
for (int indice =1 ; indice < = p ; indice++){
auxiliaire = a ; a = a*a + b*b;
b=(2*auxiliaire+b)*b;
if (c(p-indice)= =1 ) {
b = a+b; a =b-a;
}
If (n= = 1) return 1 ; else return a ;
}
72
Analyse de la version 3
Cette fois la complexité est en log (n)
73
Et la recherche dichotomique ?
On va considérer un cas plus général
74
Solutions de type diviser pour régner
Pour résoudre un problème de taille n on divise le problème en a problèmes de taille n/b et chaque sous-problème est résolu récursivement
La phase de division et combinaison des résultats partiels a une complexité en f(n)
75
L ’équation de récurrence des solutions divise pour régnerT(1) = constanteT(n) = a T(n/b) + f(n)
76
Théorème
T(n) peut alors être borné asymptotiquement comme suit :
Si f(n)= O(nlogba-e) pour une constante e>0, alors T(n) = nlogba).
Si f(n)= nlogba) , alors T(n) =O lognnlogba).
Si f(n)=(nlogba+e )pour une constante e>0, et si af(n/b) < cf(n) pour une constante c<1 alors T(n) = (f(n))
77
Lemme 1
T(n)=T(bk)=(nlogba)+
Posons g(n)=
)/(1
0
jk
j
j bnfa
)/(1
0
jk
j
j bnfa
78
Lemme 2
Si f(n)= O(nlogba-e) pour une constante e>0, alors g(n))= nlogba).
Si f(n)= nlogba) , alors g(n) =O lognnlogba).
Si af(n/b) < cf(n) pour une constante c<1 alors g(n) = (f(n))
79
Si f(n)= O(nlogba-e) pour une constante e>0, alors g(n)= nlogba).
On a alors g(n)=
Or
)(0)(log1
0
ea
j
k
j
jb
b
na
1
1log1
0
log
1
0
log)(log1
0)(log
e
eeaje
k
j
ea
j
jk
j
eaea
j
k
j
j
b
nnbn
b
an
b
na
bb
eab
b
b
80
Exemple d’application du cas 1
Recherche dichotomique du maximum
c(n)=2c(n/2)+1
81
Si f(n)= nlogba) , alors g(n) =O lognnlogba).
On obtient cette fois
Or
)()()(log1
0
a
j
k
j
jb
b
nang
)(log1 loglog1
0
log
1
0
log)(log1
0)(log
nnknn
b
an
b
na
baaj
k
j
a
j
jk
j
aa
j
k
j
j
bbb
ab
b
b
82
Exemple de ce cas
Le tri dichotomique
c(n)=2c(n/2)+n
83
Si af(n/b) < cf(n) pour une constante c<1 alors g(n) = (f(n))
c
nfnfc
bnfang
k
j
j
jk
j
j
1
)()(
)/()(
1
0
1
0
84
On se propose de multiplier entre eux des « grands nombres ».
a) Si l’on utilise la méthode naïve, combien de multiplications élémentaires sont effectuées ?
85
Soient U et V deux nombres de 2n chiffres en base B.
On peut donc écrire U=U1Bn+U2 et
V=V1Bn+ V2 où U1,U2 ,V1, V2 sont des nombres à n chiffres en base B.
86
b) On utilise l’égalité :
(U1 Bn +U2 )(V1 Bn+ V2 )= U1 V1 B2n +(U1V2 + U2 V1) Bn + U2 V2
pour calculer récursivement la multiplication. C’est à dire que l’on ramène le problème d’une multiplication de deux nombres de 2n chiffres à celui de 4 multiplications de deux nombres de n chiffres, 4 décalages et trois additions.
87
On suppose qu’additions et décalages s’effectuent en (n). Etablir une relation de récurrence permettant d’évaluer la complexité de cet algorithme récursif de multiplications et la résoudre.
88
c) On utilise maintenant l’égalité
(U1 Bn + U2 )(V1 Bn + V2 )= U1 V1 B2n +((U1 - U2 )(V2 - V1 ) + U2 V2 + U1 V1 Bn + U2 V2
pour calculer récursivement la multiplication. C’est à dire que l’on ramène le problème d’une multiplication de deux nombres de 2n chiffres à celui de 3 multiplications de deux nombres de n chiffres, 5 décalages et 6 additions. On suppose qu’additions et décalages s’effectuent en (n). Établir une relation de récurrence permettant d’évaluer la complexité de cet algorithme récursif de multiplications et la résoudre.
89
On se propose dans cet exercice de calculer la complexité de plusieurs algorithmes dont le but est de fusionner les p listes triées de longueur n contenues dans un tableau de listes en une seule liste triée de longueur np.
90
On suppose définie une classe Liste contenant entre autre une méthode permettant de fusionner une liste l1 triée de longueur n1 et un liste triée l2 de longueur n2 dont la signature est
public static Liste fusion (Liste l1, Liste l2)
et la complexité est en (n1+n2).
91
Déterminer la complexité de cette méthode en fonction de n et de p.
public static Liste fusionMultiple(Liste[] mesListes) {
Liste L=mesListes[1];
for (int i=2; i < mesListes.length; i++){
L= Liste.fusion(L,mesListes[i]);
}
return L;
}
92
On suppose maintenant que p est une puissance de 2 et l’on propose maintenant d’utiliser l’algorithme de multifusion récursif suivant :
Pour multifusionner p listes de taille n Si p=2 utiliser fusion
Sinon Multifusionner (récursivement) les p/2 première listes
Multifusionner (récursivement ) les p/2 dernières listes
Utiliser fusion pour fusionner le résultat des deux premières étapes.
93
Soit c(n,p) = la complexité de la fusion de p listes de taille n par cette méthode.
Déterminez la relation de récurrence suivie par cette suite, ainsi que c(n,2).
94
Posez d(n,p)=c(n,p)/n. Déterminez la relation de
récurrence suivie par cette suite. Montrez que d(n,p) ne dépend pas
de p. On pourra montrer par induction sur p que pour tout p >=2, d(n,p)=d(1,p) pour tout n >0.
Posez d(1,p)=f(p), et déterminez l’équation de récurrence suivie par f(p). Résoudre cette équation. En déduire c(n,p).
95
On considère le programme java récursif suivant où b est une constante entière
On suppose défini un objet table à partir d’une classe Table dérivée de la classe Vector en y ajoutant la méthode table.echanger (int i, int j) qui échange table.elementAt(i) et table.elementAt(j).
96
public void T(int debut, int fin){ // opère sur la Table table dans la tranche table[debut..fin]
int n=fin-debut+1 ; //la dimension de la tranche
if (n>1) { if (n=2) {// tri par ordre croissant des deux éléments de la tranche
if (table.elementAt(debut)>table.elementAt(fin)) {table.echanger(debut, fin) ;}}
else { T( debut, debut+n/b) ; T( fin-n/b, fin) ;
T(debut, debut+n/b) ; } }}
97
Etablir la relation de récurrence vérifiée par la complexité de cet algorithme
Si b=3/2, (dans ce cas bien sûr l’algorithme utilise la partie entière de n/b) quelle en est la complexité ?
Question bonus : démontrer que si b=3/2, T est un tri