corrigé

Preuve et Analyse des Algorithmes corrig´e

12 juin 2013

1. Temps de calcul. Une implantation d’un algorithme de temps de calculn√

n traite une instance de taille n = 64 en 8 micro-secondes.

1. Quel sera le temps de calcul pour une instance de taille 512 ? T(512) =T(8×64) = 8√

8T(64) = 128√

2∼180µsec 2. Donner un exemple d’algorithme ayant cette complexit´e.

Nous en avons vu un seul : algorithme de Karatsuba.

2. Comparaison des algorithmes de tris. Pour un entier n, et algorithme de tri X, on note :

t_X(n) = T¯_X(2n)

T¯X(n) , v_X(n) = V¯_X(2n) V¯X(n)

o`u ¯T_X(n) (respectivement ¯V_X(n)) d´esigne la moyenne du temps de calcul (respectivement du volume de m´emoire auxiliaire) utilis´e pour le traitement parX d’une instance de taille n.

Attention, l’espace occup´e par le tableau `a trier ne doit pas ˆetre comptabilis´e dans le calcul du volume de m´emoire.

1. D´eterminer tL(n), tR(n), tS(n) pour les algortihmes de tri : lin´eaire, rapide (quick- sort), et s´election.

t_L(n) = 2n

n = 2, t_R(n) = 2nlog(2n)

nlogn = 2 +2 log 2

logn , t_S(n) = 4n² n² = 4.

2. D´eterminer les fonctions v_X(n) pour les mˆemes algorithmes.

v_L(n) = 2n

n = 2, v_R(n) = log(2n)

logn = 1 + log 2

logn, v_S(n) = 1 1 = 1.

3. Quelles conclusions tirer de ces petits calculs ?

Le tri rapide est le meilleur compromis temps/m´emoire.

1

typedef s tr u c t { double r e a l , img ; } cmp ;

cmp K prd ( cmp x , cmp y ) { cmp p ;

double r , i , t ;

t = ( x . img + x . r e a l )

∗ ( y . r e a l + y . im ) ; i = x . img ∗ y . img ; r = x . r e a l ∗ y . r e a l ; p . img = r − i ;

p . r e a l= s − r − i ; return p ;

}

3. Optimisation `a la Karatsuba.

1. Que calcule la fonction prd?

Elle calcule le produit de deux nombres complexes.

2. S’inspirer de la m´ethode de Karat- suba pour utiliser une multiplication de moins.

3. On suppose que pour deux double, le temps de multiplication estλ-fois plus important que celui d’une addition ou d’une soustraction. Comparer les per- formances en fonction de λ.

On n´eglige les temps d’affectation.

L’algorithme standard `a un coˆut de 4λ+ 2 additions. L’algorithme modifi´e a un coˆut de 3λ+ 5 additions, il est plus int´eressant d`esλ >3.

4. Implantation du tri lin´eaire.

On suppose une implanation du trilin´eaire en langage C typedef unsigned long long u l l o n g ;

void t r i l i n ( u l l o n g ∗t , u l l o n g n ) ; 1. Quelles sont les pr´econditions d’utilisation ?

Il faut utiliser un tableau auxiliaire de taille n, les valeurs du tableau `a trier sont inf´erieures `an.

2. Estimer le temps de calcul d’une instance de taille 2²⁰ sur la machine obelix.

Les op´erations mises en jeu sont simple, on peut estimer utiliser une centaine d’op´erations ´el´ementaires par it´eration. Vu la fr´equence d’horloge, je propose un temps de calcul de l’ordre de

2²⁰×2⁷

3000×10⁶ ∼ 2²⁷ 2³¹ = 1

16sec 3. pour la taille 2²⁴?

16 fois plus, soit 1 seconde.

4. pour la taille 2²⁶? 64 fois plus soit 1 minute. Notons que le programme utilisera 2²⁷×2³ = 2³⁰ octets de m´emoire. Il y a un risque important de dysfonctionnement m´emoire (swap) !

2

[ drm@obelix exam−12] $ l s c p u

A r c h i t e c t u r e : i 6 8 6 Mode : 32−b i t V i t e s s e p r o c . en MHz: 3 0 0 0 . 0 0 0 [ drm@obelix exam−12] $ f r e e −b

t o t a l use d f r e e s h a r e d Mem: 1 5 8 2 9 3 1 9 6 8 8373 98528 745 533440 0

−/+ b u f f e r s / c a c h e : 389427200 1 1 9 3 5 0 4 7 6 8 Swap : 3 1 8 7 6 6 6 9 4 4 0 31 8 7 6 6 6 9 4 4

[ drm@obelix exam−12] $ e c h o ’ l ( 1 5 8 2 9 3 1 9 6 8 ) / l ( 2 ) ’ | bc −l 3 0 . 5 5 9 9 5 2 1 0 5 9 6 2 8 4 1 0 9 7 5 6

Fig. 1 – capacit´es de la machine obelix 5. Analyse d’une fonction r´ecursive.

On note K(n), le nombre de comparai- sons r´ealis´ees par la fonction r´ecursiveproc quand elle est appliqu´ee `a un tableau de n entiers.

1. Donner une formule r´ecursive du temps de calcul.

Il existe une constante K telle que, pour n >1,

K(n) = 2K(n/2) +K, 2. DonnerK(n) en fonction de n.

lin´eaire

3. M´ezaufait, que fait cete fonction ? recherche r´ecursive de minimum.

1 i n t p r o c ( i n t∗ t , i n t n )

{ i n t x , y , p ; 2

3 i f ( n > 1 ) {

4 p = n / 2 + ( n & 1 ) ;

5 x = p r o c ( t , n/2 ) ;

6 y = p r o c ( t + n / 2 , p ) ;

7 i f ( x > y ) x = y ;

} 8

9 e l s e x = ∗t ;

10 return x ;

} 11

6. Ordre d’une permutation. On consid`ere les permutations de l’ensemble{0,1, . . . , n−

1}. Une permutationπ est repr´esent´ee naturellement par un tableau de taillen. Pour un entier x < n, on d´efinit la suite d’entiers (xn)n≥0

x₀ :=x, ∀n >0 x_n=π(xn−1),

on note alors r(x) le plus petit entier strictement positif tel que x₀ =x_r(x). L’ordre de π est le ppcm des valeurs de r, un tel ppcm peut ˆetre calcul´e de mani`ere it´erative :

ppcm(a1, a2, a3, . . .) = ppcm(ppcm(ppcm(a1, a2), a3), . . .)

1. D´eterminer les valeurs der, puis l’ordre de la permutation, correspondant au tableau de taille 15 :

0 2 4 6 1 10 12 14 8 3 5 7 9 11 13

On calcule les images suc´essives : 0 → 0 i.e. r(0) = 1, 1 → 2 → 4 → 1 i.e.

r(1) = 3, 3 → 6 → 12 → 9 → 3 i.e. r(3) = 4, 5 → 10 → 5 i.e. r(5) = 2, 7→14→13→11→73 i.e. r(7) = 4, 8 →8 i.e.r(8) = 1. Le PPCM vaut 12.

2. L’entierr(x) est effectivement bien d´efini, pourquoi ?

La suite x_n prend un nombre fini de valeurs, il existe i < j tels que x_i = x_j, et, commme π est une bijection, π^j−i(x₀) = x₀.

3

3. Ecrire une fonction ordre(p, n) qui calcule l’ordre de la permutation p.

1 i n t o r d r e ( i n t∗ p , i n t n )

{ i n t r e s = 1 , r ; 2

3 i n t vu [ n ] ;

4 i n t x , y ;

5 f o r( x = 0 ; x < n ; x++ )

6 vu [ x ] = 0 ;

7 f o r( x = 0 ; x < n ; x++ )

8 i f ( ! vu [ x ] ) {

9 r = 0 ;

10 y = x ;

11 do {

12 y = p i [ y ] ;

13 vu [ y ] = 1 ;

14 r ++;

} while ( y!=x ) ; 15

16 r e s = ppcm ( r e s , r ) ;

} 17

18 return r e s ;

} 19

4