Lycée Thiers mpsi 123

Lycée Thiers
mpsi 123
CORRECTION DS 2
Exercice 1 - Diviser pour mieux régner ?
1) Calcul de la somme des termes d’une liste d’entiers :
let sum l = aux 0 l where
rec aux sp = function (* sp pour Somme Partielle *)
| [] -> sp
| h::t -> aux (h+sp) t
;;
La fonction aux est récursive terminale, comme demandé.
2) Partage d’une liste en deux demi-listes :
let rec partage = function
| [] -> [],[]
| [x] -> [x],[]
| x::y::r -> let (g,d) = partage r in (x::g,y::d)
;;
3) Si la liste est vide, la somme est nulle (par convention). Si la liste est réduite à un élément, la somme
est donnée par cet élément. Enfin, si la liste est de longueur 2, on la partage en deux demi-listes (avec
la fonction partage ci-dessus), dont on calcule récursivement la somme des termes, puis on ajoute les
résultats.
4) Calcul de la somme des termes d’une liste d’entiers, en divisant pour régner :
let rec sumbis = function
| [] -> 0
| [x] -> x
| l -> let (g,d) = partage l in (sumbis g) + (sumbis d)
;;
5) Montrons par récurrence forte que, pour tout n 1 :
T (n) = n − 1
C’est le cas pour n = 1. Supposons le résultat établi aux rangs inférieurs à n, pour un certain n 2. Deux
cas se présentent ...
Si n est pair, alors :
et si n est impair, alors :
( ) n − 1
T (n) = T + T
2
L’hérédité est établie.
( ) ( )
n n
T (n) = 2T + 1 = 2
2 2 − 1 + 1 = n − 1
( n + 1
2
) ( ) ( )
n − 1 n + 1
+ 1 = − 1 + − 1 + 1 = n − 1
2
2
6) Si l’on note T (n) le nombre d’additions engendrées par l’appel sumbis l, lorsque l est une liste de longueur
n, on a T (0) = T (1) = 0 et, pour tout n 2 :
(⌊ ⌋) (⌈ ⌉)
n n
T (n) = T + T + 1
2 2
D’après le 5°), cette méthode dichotomique n’est donc pas meilleure que la méthode “naïve” de la question
1°). On peut même affirmer qu’elle est moins performante, car la mise en œuvre de la récursion possède
un coût ! La preuve en chiffres :

CORRECTION DS 2 2
#open "sys";;
let rec jusque = function
| 0 -> []
| n -> n :: (jusque (n - 1))
;;
let L = jusque 100000 in
let t0 = time() in
let s0 = sum L in
let t1 = time() in
let s1 = sumbis L in
let t2 = time() in
(t1 -. t0, t2 -. t1)
;;
- : float * float = 0.0, 0.533333333333
Exercice 2 - Vecteurs “presque” triés
1) Le tri d’un vecteur peut modifier physiquement le vecteur en question (sa structure initiale est perdue) ou
bien s’effectuer sur une copie de celui-ci. Dans le premier cas, on parle de tri “en place” et dans le second,
de tri “hors place”. Le principal avantage d’un tri en-place est évidemment l’économie de mémoire.
2) Le tri par fusion est un tri récursif par comparaison. Une séquence vide ou de longueur 1 est déjà triée.
Pour une séquence de longueur n 2, on partage celle-ci en deux séquences de longueur moitié (plus
précisément, l’une de longueur ⌊ ⌋ ⌈ ⌉
n
2 et l’autre de longueur n
2 ), ces deux séquences sont ensuite triées
récursivement, et leurs versions triées sont alors fusionnées.
La mise en œuvre de cet algorithme repose donc sur l’écriture de trois fonctions : la première partage
une séquence quelconque en deux moitiés, la seconde fusionne deux séquences triées en une seule, la
troisième effectue le tri proprement dit en faisant appel aux deux précédentes.
La complexité (en nombre de comparaisons) est “quasi-linéaire” : elle vérifie T (n) = Θ (n ln (n)) .
3) En mettant côte à côte le vecteur v et sa version triée v ′ :
v : 3 1 2 0 5 4 9 8 7 6
v ′ : 0 1 2 3 4 5 6 7 8 9
on constate que la distance maximum entre un terme de v et le terme de même valeur dans v ′ est d = 3.
Ainsi, le vecteur v est 3−quasi-trié. Il n’est pas 2−quasi-trié puisque, par exemple : v. (0) = v ′ . (3) .
4) Dans la définition proposée, le problème vient du fait que plusieurs termes du vecteur peuvent être égaux.
Il faut donc plutôt considérer qu’un vecteur v est d−quasi-trié lorsqu’en notant v ′ sa version triée :
∀i ∈ {0, · · · , n − 1} , ∃j ∈ {0, · · · , n − 1} ; ( v. (i) = v ′ . ( j ) et ∣ ∣ ∣i − j
∣ ∣∣ d
)
5) Une idée est de trier successivement (par fusion) les sous-vecteurs v [0 : 2d[ , v [d : 3d[ , etc ... en terminant
éventuellement avec v [kd : n[ (si n n’est pas multiple de d et en posant k = ⌊ n
d
⌋
).
Lorsque v [0 : 2d[ est trié, on est sûr que chaque terme v [0 : d[ a trouvé sa place définitive.
Puis, lorsque v [d : 3d[ est trié, même chose pour v [d : 2d[ et ainsi de suite.
On effectue donc Θ ( n
d
)
tris par fusion de vecteurs de longueur 2d (sauf éventuellement un dernier vecteur
plus court) et le nombre total de comparaisons est donc Θ (n ln (d)) .

CORRECTION DS 2 3
Exercice 3 - Suite de Conway
1) Fonction separe :
Type : ’a list → int * ’a * ’a list
En entrée : un liste non vide h::...::h::y (h répété n fois)
En sortie : le triplet n,h,y
let separe = function
| [] -> failwith "liste vide"
| h::t -> aux 1 t where
rec aux count = function
| [] -> (count, h, [])
| head::tail -> if h = head then aux (count + 1) tail
else (count, h, head::tail)
;;
Exemple :
separe [1;1;1;2;2;3];;
- : int * int * int list = 3, 1, [2; 2; 3]
2) Fonction lire :
Type : int list → int list
En entrée : une liste d’entiers l
En sortie : la liste obtenue en “lisant” l
let rec lire = function
| [] -> []
| l -> let (x,n,t) = separe l in x :: n :: lire t
;;
Exemple :
lire [1;1;1;2;2;3];;
- : int list = [3; 1; 2; 2; 1; 3]
3) Fonction conway :
Type : int → int list
En entrée : un entier n 0
En sortie : le n−ème terme de la suite de Conway, sous la forme d’une liste de chiffres
let rec conway = function
| 0 -> [1]
| n -> lire (conway (n-1))
;;
Exemple :
conway 5;;
- : int list = [3; 1; 2; 2; 1; 1]
Remarque. Cette suite possède de curieuses propriétés. Pour en savoir plus, on pourra consulter la page web
http://fr.wikipedia.org/wiki/Suite_de_Conway

CORRECTION DS 2 4
Exercice 4 - Somme maximale d’un sous-vecteur
1) D’évidence, si tous les termes de v sont positifs ou nuls, alors σ ⋆ (v) est donné par σ (v) .
2)
2.a) Pour tout couple ( i, j ) tel que 0 i j n − 1, on doit calculer la somme
j − i additions. Au total :
⎛ ⎞ ⎛ ⎞
∑n−1
∑n−1
∑n−1
n−1−i ∑
T (n) = j − i ⎜⎝ ⎟⎠ = ⎜⎝
k⎟⎠ = 1 ∑n−1
(n − 1 − i) (n − i) = 1 2
2
i=0
j=i
i=0
k=0
i=0
j∑
v. (k), ce qui représente
k=i
n∑
k (k − 1)
Comme k (k − 1) = 1 3
[(k + 1) k (k − 1) − k (k − 1) (k − 2)] , on obtient (sommation télescopique) :
Il est alors clair que T (n) = Θ ( n 3) .
2.b) Implémentation de la méthode 0 :
let mssp_0 v =
let n = vect_length v in
let left = ref 0 in
let right = ref 0 in
let smax = ref v.(0) in
for i = 0 to n - 1 do
for j = i to n - 1 do
let s = ref 0 in
for k = i to j do
s := !s + v.(k)
done;
if !s > !smax then (
left := i;
right := j;
smax := !s
)
done
done;
(!smax, !left, !right)
;;
T (n) = 1 (n + 1) n (n − 1)
6
3) Pour chaque i ∈ {0, · · · , n − 1} , l’algorithme ci-dessus calcule toutes les sommes v. (i) , v. (i) + v. (i + 1) , etc ...
v. (i) + · · · + v. (n − 1) . De nombreuses additions sont donc effectuées plusieurs. On peut donc améliorer les
choses ainsi :
let mssp_1 v =
let n = vect_length v in
let left = ref 0 in
let right = ref 0 in
let smax = ref v.(0) in
for i = 0 to n - 1 do
let s = ref 0 in
for j = i to n - 1 do
s := !s + v.(j);
if !s > !smax then (
left := i;
right := j;
smax := !s
)
done
done;
(!smax, !left, !right)
;;
k=1

CORRECTION DS 2 5
4)
A présent, le nombre d’additions effectuées est :
∑n−1
∑n−1
T (n) = (n − 1 − i) = k =
et la complexité est donc passé à T (n) = Θ ( n 2) .
4.a) On a s 0 = v. (0) et, pour :
Il est par ailleurs clair que :
i=0
k=0
⎧
v. ( j ) si s j−1 < 0
⎪⎨
s j =
⎪⎩ s j−1 + v. ( j ) sinon
σ ⋆ (v) = max {s 0 , · · · , s n−1 }
n (n − 1)
2
4.b) Ce qui précède montre qu’on peut calculer σ ⋆ (v) comme suit :
let mssp_2 v =
let n = vect_length v in
let max_local = ref v.(0) in
let max_global = ref v.(0) in
for j = 1 to n - 1 do
if !max_local < 0
then max_local := v.(j)
else max_local := !max_local + v.(j);
;;
if !max_local > !max_global then max_global := !max_local;
done;
!max_global
Dans la fonction ci-dessus, max_global est une référence sur ce qui sera au final la plus grande somme,
c’est-à-dire σ ⋆ (v) . Tandis que max_local est une référence sur la plus grande somme parmi celles qui
se terminent par le terme d’indice courant (à savoir j).
On constate que la complexité est à présent O (n) ; en effet, on compte une seule boucle de longueur
n − 1 et au plus une addition par tour de boucle.
On peut étoffer cette fonction pour qu’elle calcule aussi, comme les deux précédentes, les indices
extrêmes d’un sous-vecteur qui réalise la somme maximale :
let mssp_lin v =
let n = vect_length v in
let left_local = ref 0 in
let left_global = ref 0 in
let right = ref 0 in
let max_local = ref v.(0) in
let max_global = ref v.(0) in
for j = 1 to n - 1 do
if !max_local < 0 then (
max_local := v.(j);
left_local := j
)
else max_local := !max_local + v.(j);
;;
if !max_local > !max_global then (
max_global := !max_local;
left_global := !left_local;
right := j
)
done;
(!max_global, !left_global, !right)

CORRECTION DS 2 6
5)
5.a) Le principe “diviser pour régner” consiste, étant donné un problème de taille n, à le fractionner en un
certain nombre a de problèmes de taille n/b.
Ces derniers sont traités récursivement et leurs solutions respectives sont alors assemblées d’une
manière appropriée, pour produire une solution au problème posé.
5.b) Pour résoudre le MSSP via le principe diviser pour régner, on a besoin d’une fonction qui détermine
la somme maximale pour les vecteurs “à cheval”.
Si l’on note a, b les indices de début et de fin et i l’indice intermédiaire, il est clair que σ (v [a : i])
doit être maximale parmi les sommes de sous-vecteurs qui se terminent avec le terme d’indice i et que
σ (v [i : b]) doit être maximale parmi les sommes de sous-vecteurs qui démarrent avec ce même terme.
En en déduit le code suivant :
let mss_a_cheval v debut interm fin =
let left = ref interm in
let sLeftMax = ref 0 in
let s = ref 0 in
for i = interm downto debut do
s := !s + v.(i);
if !s > !sLeftMax then (
left := i;
sLeftMax := !s
)
done;
let right = ref interm in
let sRightMax = ref 0 in
s := 0;
for i = interm + 1 to fin do
s := !s + v.(i);
if !s > !sRightMax then (
right := i;
sRightMax := !s
)
done;
(! sLeftMax + !sRightMax, !left, !right)
;;

CORRECTION DS 2 7
Ensuite, la fonction de résolution proprement dite :
let mss_dpr v =
let n = vect_length v in mss_aux 0 (n - 1) where
rec mss_aux a b =
if a = b then (v.(a), a, a)
else if b = a + 1 then let s = v.(a) + v.(b) in (
if v.(a) > v.(b) then (
if v.(a) > v.(a) + v.(b) then (v.(a), a, a)
else (s, a, b)
)
else (
if v.(b) > v.(a) + v.(b) then (v.(b), b, b)
else (s, a, b)
)
)
else let m = (a + b) / 2 in
let (smax0, left_0, right_0) = mss_aux a m in
let (smax1, left_1, right_1) = mss_aux m b in
let (smax01, left_01, right_01) = mss_a_cheval v a m b in
if smax0 > smax1 then (
if smax01 > smax0 then (smax01, left_01, right_01)
else (smax0, left_0, right_0)
)
else (
if smax01 > smax1 then (smax01, left_01, right_01)
else (smax1, left_1, right_1)
)
;;
5.c) On a la relation de récurrence suivante :
(⌊ ⌋) (⌈ ⌉)
n n
T (n) = T + T + O (n)
2 2
d’où, d’après le second cas du Master Theorem :
T (n) = Θ (n ln (n))
Cet algorithme est quasi-linéaire. Il est donc moins performant que celui vu à la question 4° (qui est
linéaire et optimal : il est connu sous le nom d’algorithme de Kadane).