TD 4 Corrige
TD 4 Corrige
TD 4 Corrige
Complexité
Nga Nguyen - Stefan Bornhofen - Peio Loubière
1 Puissance
Voici 2 versions différentes permettant de calculer la puissance xn vues en
TD 3. Comparer leur complexité :
1 Fonction p u i s s a n c e ( x , n : Entier ) : Entier
2 Début
3 Si n = 0 Alors
4 retourner 1
5 Sinon
6 retourner x∗ p u i s s a n c e ( x , n−1)
7 FinSi
8 Fin
9
10 ===============
11
12 Fonction p u i s s a n c e −d i c ( x , n : Entier ) : Entier
13 Début
14 Si n = 0 Alors
15 retourner 1
16 SinonSi ( n mod 2 = 0 )
17 retourner p u i s s a n c e −d i c ( x∗x , n / 2 )
18 Sinon
19 retourner x∗ p u i s s a n c e −d i c ( x , n−1)
20 FinSi
21 Fin
1
Solution :
On choisit la multiplication comme opération élémentaire. On note C(n) le
nombre de multiplications au rang n.
– Version 1 :
C(0) = 0
C(n) = 1 + C(n − 1)
⇒ complexité linéaire (O(n)).
– Version 2 :
C(0) = 0
C(n) = 1 + C(n/2) , si n pair (1)
C(n) = 1 + C(n − 1) , si n impair (2)
Dans le pire des cas, n aura la forme 2k + 2k−1 + ... + 21 + 1 pour que l’on
passe par (2) puis (1) puis (2) puis (1) ... On a :
2
Solution :
– Algorithme en O(N) ?
Pour montrer que cet algorithme est en O(n), on va supposer que :
∀i ≤ n, C(i) ≤ i
3 Mots décroissants
Soit A un alphabet fini, muni d’un ordre total ≤. On considère A∗ l’ensemble
des mots finis sur A. Soit m un mot de longeur l. Pour tout i, 1 ≤ i ≤ l, on note
mi la ième lettre de m. On dit qu’un mot m de longueur l est décroissant, s’il
est vide ou si pour tout i, 1 ≤ i ≤ l − 1, mi+1 ≤ mi . Si de plus il n’y a pas deux
lettres égales dans le mot m, m est dit strictement décroissant.
Soit A∗D le sous ensemble de A∗ constitué des mots décroissants, et A∗SD le sous-
ensemble de A∗D constitué des mots strictement décroissants.
3
Solution :
1 Fonction D e c r o i s s a n t (m : Chaı̂ne ) : Booléen
2 Variables l : Entier
3 Début
4 l ← longueur (m)
5 Si ( l ≤ 1 ) Alors
6 retourner v r a i
7 Sinon
8 retourner ( e x t r a i t (m, 1 , 1 ) ≥ e x t r a i t (m, 2 , 1 ) ) et
D e c r o i s s a n t ( e x t r a i t (m, 2 , l −1) )
9 FinSi
10 Fin
11
12 ======
13
14 Fonction S i m p l i f i e (m : Chaı̂ne ) : Chaı̂ne
15 Variables l : Entier
16 Début
17 l ← longueur (m)
18 Si ( l ≤ 1 ) Alors
19 retourner m
20 Sinon
21 Si ( e x t r a i t (m, 1 , 1 ) = e x t r a i t (m, 2 , 1 ) ) Alors
22 retourner S i m p l i f i e ( e x t r a i t (m, 2 , l −1) )
23 Sinon
24 retourner e x t r a i t (m, 1 , 1 ) & S i m p l i f i e ( e x t r a i t (m, 2 ,
l −1) )
25 FinSi
26 Fin
27
28 ======
29
30 Fonction I n t e r s e c t i o n (m1, m2 : Chaı̂ne ) : Chaı̂ne
31 Variables l 1 , l 2 : Entier , c1 , c2 : Chaı̂ne
32 Début
33 l 1 ← longueur (m1)
34 l 2 ← longueur (m2)
35 // s i un de 2 mots e s t vide , on retourne un mot v i d e
36 Si ( l 1 = 0 ) ou ( l 2 = 0 ) Alors
37 retourner ””
38 Sinon // on compare l e s 2 p r e m iè r e s l e t t r e s
39 c1 ← e x t r a i t (m1, 1 , 1 )
40 c2 ← e x t r a i t (m2, 1 , 1 )
41 Si ( c1 = c2 ) Alors
42 retourner c1 & I n t e r s e c t i o n ( e x t r a i t (m1, 2 , l 1 −1) ,
e x t r a i t (m2, 2 , l 2 −1) )
43 SinonSi ( c1 > c2 ) 4
44 retourner I n t e r s e c t i o n ( e x t r a i t (m1, 2 , l 1 −1) ,m2)
45 Sinon
46 retourner I n t e r s e c t i o n (m1, e x t r a i t (m2, 2 , l 2 −1) )
47 FinSi
48 FinSi
49 Fin
– Decroissant : complexité linéaire O(l) où l est la longueur du mot
– Simplifie : complexité linéaire O(l) où l est la longueur du mot
– Intersection : complexité O(l1+l2) où l1 et l2 sont les longueurs de 2 mots