TD1 : Complexit e algorithmique

TOP: Techniques and tOols for Programming

Premi` ere ann ee Exercice 1: Complexit e asymptotique et Faisabilit e pratique. Question 1: Compl` etez les tableaux suivants. Dans le tableau (a), il sagit de calculer le nombre dop erations n ecessaire pour ex ecuter lalgorithme en fonction de sa complexit e et de la taille dinstance du probl` eme trait e. Dans le tableau (b), il sagit de calculer le temps n ecessaire ` a cela en supposant que lon dispose dun ordinateur capable de r ealiser 109 op erations par seconde. Dans le tableau (c), on calcule la plus grande instance de probl` eme traitable dans le temps imparti. On rappelle que une nanoseconde (ns) vaut 109 s et que une microseconde (s) vaut 106 . De plus, 1/2 xy xy 10 = 10 et n = n .
(a) Nombre dop erations. (b) Temps n ecessaire ` a 109 op/sec.

Complexit e n n2 n3 2n n 3 n log2 (n)

n=10 101 102 103 103 3.3 2.15 3.3

n=100 102 104 106 1030 10 4.64 6.6

n=1000 103 106 109 10300 31 10 9.9

(note 1) : 30000 milliards dann ees, 2300 fois l age de lunivers (estim e` a 13.7 milliards dann ees).

C
9

R O
Complexit e n n2 n3 2n n 3 n log(n)

E R
R eponse Fin r eponse 1s 109 103 29 3 104 1018 1027 1030 000 000

Complexit e n n2 n3 2n n 3 n log n

N O I T C
n=10 10ns 100ns 1s >1s n=100 100ns 10s 1ms 10ns 4.64ns 6.6ns n=1000 1s 1ms 1s
10284 ans

(note 1)

3.3ns 2.15ns 3.3ns

31ns 10ns 9.9ns

(c) Plus grande instance faisable ` a 109 op/sec.

1h 1012 106 104 39

1 an 1016 108

erations. Donc lalgo n fait 10 op erations, n2 log2 (109 ) , log n 210 1s=10 op (109 ), 2n 1h, cest idem 3600. En gros, on calcule le nb dop sur la premi` ere ligne, et apr` es on extrait des racines carr es, des racines cubiques, des logs et des exp. 7 9 7 2(10 ) = (2100 )10 (1030 )10 = 10300,000,000 A comparer au nombre estim e de particules dans lunivers : 1080 . . .

O C

N O I T C E R R
2 105 53 1032 1048 1024 1036 R eponse
9
9

Fin r eponse

TD1 : Complexit e algorithmique Exercice 2: Donnez la complexit e des programmes suivants. Vous donnerez une borne sup erieure avec un O() dans un premier temps, puis vous anerez votre calcul en utilisant la notation ().
1 2 3

listing 1 pour i = 1 a ` n faire pour j = 1 a ` n faire x += 3 listing 4 pour i = 1 a ` n faire pour j = 1 a ` n faire pour k = 1 a ` n faire x := x+a

1 2 3

listing 2 pour i = 1 a ` n faire pour j = 1 a ` i faire x += 3

1 2 3 4

1 2 3 4

listing 5 pour i = 1 a ` n faire pour j = 1 a ` i faire pour k = 1 a ` j faire x := x+a

R eponse

Le listing 6 a des for( ; ;) car on divise i par 2 ` a chaque etape. Cest impossible ` a ecrire en pseudo-pascal, il me semble. 1. (n2 ) trivialement (g erald : ca veut dire 0(n2 ) et (n2 ) en m eme temps ;)

2. O(n2 ) facilement (n est une borne sup du nombre de tours de boucles) (n2 ) un peu plus p eniblement (en d enombrant exactement les etapes comme on a fait en cours pour le tri s election qui ressemble beaucoup)

3. O(n) la boucle interne a tjs un nombre constant dop erations (10 etapes). Les variations de longueur sur la boucle externe etant constantes, on les ignore. 4. (n3 ) trivialement 5. O(n3 ) facilement car les boucles internes font au plus n tours. =
i[1,N ] j [1,i]

R R O C
En d enombrant, on trouve =
1 2 (2N +1)(N +1)N 6

N O I T C E
1 2 3 1 2 3

listing 3 pour i = 5 a ` n-5 faire pour j = i-5 a ` i+5 faire x += 3 listing 6 for (i = n; i>1; i = i/2) for (j=0;j<i;j++) x := x+a

i2 +
i[1,N ]

j=
i[1,N ]

i[1,N ] j [1,i] k[1,j ]

i(i + 1) = 2

1 2

i[1,N ]

N (N +1) 2

(n )

6. O(n log2 (n)) assez trivialement, une fois quon sait que diviser le travail ` a chaque etape introduit du log dans les co uts. Lan prochain, je vous dirais comment le montrer. Je me souviens juste que cest pas si dur... Mais en fait, ce code est dans (n) (et donc aussi dans O(n) ; G erald, tes pas attentif !). Cest parce que la boucle int erieure sarr ete ` a i et pas ` a n. Donc, si on compte les etapes faites par j dedans, on trouve : 1+2+4+8+...+n. Autrement dit, si on pose n = 2p ,
p 2k p

Ben oui, ya quand meme des fois o` u cest plus coquin, les d ecomptes de complexit e, hein. Fin r eponse

Exercice 3: Cas favorable, d efavorable. Co ut moyen. Question 1: Etudiez le nombre dadditions r ealis ees par les algorithmes suivants dans le meilleur cas, le pire cas, puis dans le cas moyen en supposant que les tests ont une probabilit e de 1 etre 2 d vrai. Question 2: Donnez une instance du code 2 de co ut tavg .

Question 4

code 1 : 0 au mieux, n au pire, n/2 en moyenne. code 2 : 1 au mieux, n au pire. Donc, en moyenne, on a aussi n/2 Question 5 Yen a pas, bien s ur. Dieu que je suis machiav elique. Fin r eponse 2

O C

N O I T C E R R
1= 2k =
k=1 j =1 k=1

2p+1 1 1 = n (n) 2 2

1 2 3

code 1 pour i de 1 a ` n faire si T[i]>a alors s := s + T[i]

1 2 3 4

code 2 si a > b alors pour i = 1 a ` n faire x := x+a sinon x := x+b

R eponse

TD1 : Complexit e algorithmique

Exercice 4: Un peu de calculabilit e. Question 1: D emontrez que tous les algorithmes de tri comparatif sont dans (n log n). Indice : Il faut repartir de la sp eciciation du probl` eme, d enombrer le nombre de solutions candidates, et quantier la somme dinformation accumul ee lors de chaque test. Cela permet de calculer la borne inf erieure de tests ` a r ealiser pour s electionner la bonne solution parmi les candidates.

Cet exercice est hors sujet vis-` a-vis des evaluations, mais faut rester challenging :) Il faut donc repartir de la spec du probl` eme : input : tableau d el ements output : permutation sur les el ements telle que ... Combien de permutations sont possibles ? n! bien s ur. On cherche donc la bonne permutation parmis n! existantes. Les algos comparatifs basent leur d ecision sur des comparaisons (si, si). Donc, ` a chaque etape, ils gagnent une information bool eenne. Donc, en 3 etapes, ils peuvent trouver le bon el ement dans un ensemble de 23 possibles. Si on a un algo comparatif (correct) qui r epond en f (n) etapes, on est donc s ur que 2f (n) > n! car sil avait pas assez dinfo, il pourrait pas trouver la bonne permutation. Donc, f (n) > log (n!). Hors, les taupins dans la salle devraient savoir montrer en utilisant lapproximation de Stirling que log(n!) (n log n) Donc un algo comparatif correct est forc ement dans (n log n). Voyez, les preuves de calculabilit e sont pas forc ement infaisables.

Exercice 5: Tri par d enombrement [Seward 1954]. Si on sait que les valeurs sont comprises entre 0 et max (avec max pas trop grand), on peut trier les valeurs en comptant tout dabord le nombre de 0, le nombre de 1, le nombre de 2 ... le nombre de max en entr ee. Ensuite, il sut de parcourir le tableau ` a nouveau en indiquant la bonne quantit e de chaque valeur. Question 1: Ecrire cet algorithme. On utilisera un tableau annexe count o` u count[i] indique le nombre de i dans le tableau initial. R eponse
1 2 3 4 5 6 7

R R O C

N O I T C E

Fin r eponse

for (i=0;i<length;i++) count[ tab[i] ]++; j=0 for (u=0;u<max;u++) for (v=0;v<count[u];v++) tab[j] = u j++

Question 2: Calculer la complexit e asymptotique de cet algorithme. R eponse

La premi` ere boucle a clairement len tours. Pour le second nid de boucle, cest agacant ` a calculer au premier abord. Le plus simple est de compter le nombre de valeurs successives que la variable j prend : pile-poil len. Du coup, on est en (n + n) = (n). Ben oui, cest lin eaire...

Question 3: Discutez cette complexit e par rapport ` a la borne th eorique inf erieure d emontr ee ` a lexercice pr ec edent. R eponse Bon, la question est pas claire, mais jarrive pas bien ` a le dire sans que l enonc e de la question 6 spoile le travail de la question 5. Nous avons vu en cours que la complexit e des algorithme de tri bas es sur la comparaison des el ements est (n log n), mais il est bien possible que le fait que ce soit que pour les tris comparatifs soit un peu pass e` a la trappe. L` a, on fait mieux car on ne compare pas les el ements entre eux, mais on utilise une connaissance suppl ementaire sur les donn ees (le fait que le max est petit). 3

O C

N O I T C E R R
Fin r eponse Fin r eponse

TD1 : Complexit e algorithmique

Remarquons egalement quon est plus en (1) en m emoire, mais en (max). Ce r esultat est amusant vis-` a-vis de lexercice pr ec edent, mais ce nest pas si choquant que le tri par d enombrement aille plus vite que la borne inf erieure des tris comparatifs vu quil acquiere ses infos par un autre moyen que les comparaisons. Fin r eponse

R R O C

N O I T C E

O C

N O I T C E R R
4