Vous êtes sur la page 1sur 11

‭Chapitre 8‬‭option informatique‬‭Diviser pour régner‬

‭1. Introduction‬
‭1.1 Algorithme d’exponentiation rapide‬
‭ onsidérons‬‭un‬‭entier‬ ‭n‬ ‭et‬‭un‬‭élément‬ ‭x‬ ‭d’un‬‭monoïde‬‭multiplicatif‬‭(‭X
C ‬ ‬‭,‭∗‬ ‬‭)‬‭(‭x‬ ‬ ‭peut‬‭donc‬‭être‬‭un‬‭nombre,‬‭une‬
‭n‬
‭matrice,‬‭un‬‭polynôme.‬‭.‬‭.),‬‭et‬‭intéressons-nous‬‭au‬‭calcul‬‭de‬‭x‬ ‭,‬‭en‬‭choisissant‬‭pour‬‭mesure‬‭du‬‭coût‬‭le‬‭nombre‬
‭de‬‭multiplications effectuées. Un algorithme simple‬‭vient immédiatement à l’esprit :‬

let
‭ rec‬‭puissance x =‬‭
function‬
|
‭ 0‬‭−‭
>
‬ 1‬
|
‭ 1‬‭−‭
>
‬ x‬
|
‭ n‬‭−‭
>
‬ x * puissance x (n‬
‭−‬‭
1) ;;‬

(‭ par souci de lisibilité, tous nos algorithmes seront de type‬‭int‬‭−‬‭> int‬‭; pour adapter ceux-ci à un autre‬
‭type il‬‭suffira de modifier l’élément neutre‬‭
1‬‭et‬‭le produit‬‭
*‭)‬.‬
‭À l’évidence, le nombre de multiplications effectuées est égal à‬‭n‬‭−‬‭1 ; il s’agit donc d’un algorithme‬‭de coût‬
‭linéaire.‬
‭Il est cependant très facile de faire mieux, en utilisant l’algorithme suivant, connu sous le nom d’algorithme‬
‭d’‬‭exponentiation rapide‬‭:‬

let
‭ rec‬‭puissance x =‬‭
function‬
|
‭ 0‬‭−‭
>
‬ 1‬
|
‭ 1‬‭−‭
>
‬ x‬
|
‭ n when n mod 2 = 0‬‭−‬‭
> puissance (x * x) (n / 2)‬
|
‭ n‬‭−‭
>
‬ x * puissance (x * x) (n / 2) ;;‬
‭j‬‭n‬ ‭k‬
‭Il s’agit d’une fonction inductive dont la terminaison est justifiée par l’inégalité :‬‭∀‬‭n‬‭>‬‭2,‬ ‭2‬ ‭< n‬‭et‬‭la validité‬
‭k‬ ‭2‬ ‭k‬ ‭2‬‭k‭+
‬ 1‬
‭par les égalités‬ ‭= (‬‭x‬ ‭)‬ ‭x‬
‭:‬ ‭2‬ ‭k‬
‭=‬‭x‬‭(‭x‬ ‬ ‭)‬
‭‬ ‭2‬
‭‭x‬ ‬
‭Si on note‬‭c‬‭n‬‭le nombre de multiplications effectuées,‬‭on dispose des relations :‬‭c‬‭0‬‭=‬‭c‭1‬ ‬‭= 0,‬‭c‬‭2‬‭k‬‭=‬‭c‭k‬ ‬‭+ 1 et‬
‭c‭2‬ ‭k‬ ‬‭+1‬‭=‬‭c‭k‬ ‬‭+ 2, soit encore :‬‭c‬‭n‬‭=‬‭c‭b‬ ‭n‬ /‬‭2c‬‭+ 1 + (‬‭n‬‭mod 2).‬
‭p‬ ‭k‬
‭‬
X ‭b‬‭k‭2
‬ ‬ ‭, avec‬‭b‬‭p‬‭= 1.‬‭p‭−
‬ 1‬
‭Considérons la décomposition de‬‭n‬‭en base 2‬
‭:‬‭n‬‭= [‬‭b‬‭p‭,‬ b‬‭p‭−‬ 1‬‭,...,b‬‭0‬‭]‭2‬ ‬‭=‬‭k‬‭=0‬
‭j‭n
‬ ‬ ‭k‬
‭Nous avons‬ ‭2‬ ‭= [‬‭b‬‭p‭,‬ b‬‭p‭−‬ 1‬‭,...,b‬‭1‭]‬ ‬‭2‬‭et‬‭n‬‭mod 2 =‬‭b‭0‬ ‬‭,‬‭et il est alors facile d’obtenir :‬‭c‬‭n‬‭=‬‭p‬‭+‭X
‬‬
‭b‭k‬ ‬‭.‬
‭k‭=
‬ 0‬
‭p‬
‭Le coût dans le meilleur des cas intervient lorsque‬‭n‬‭est une puissance de 2 : si‬‭n‬‭= 2‬ ‭, alors‬‭c‬‭n‬‭=‬‭p‬‭= log‬‭n‭.‬‬‭Le‬
‭p‬‭+1‬
‭coût dans le pire des cas intervient lorsque‬‭n‬‭= 2‬ ‭−‬‭1 (l’écriture binaire de‬‭n‬‭ne comporte que des‬‭1) : nous‬
‭avons alors‬‭c‭n‬ ‬‭= 2‬‭p‬‭= 2blog‬‭n‬‭c.‬
‭3‬
‭ t il n’est guère difficile d’établir qu’en moyenne,‬‭c‬‭n‬‭=‬ ‭2‬‭blog‬‭n‬‭c.‬
E
‭Il s’agit donc d’un algorithme de coût logarithmique.‬

‭1.2 Diviser pour régner‬


‭ ’algorithme‬‭d’exponentiation‬‭rapide‬‭que‬‭nous‬‭venons‬‭d’étudier‬‭est‬‭un‬‭exemple‬‭d’utilisation‬‭d’un‬‭paradigme‬
L
‭de‬‭programmation‬‭connu‬‭sous‬‭le‬‭nom‬‭de‬‭diviser‬‭pour‬‭régner‬‭(ou‬‭divide‬‭and‬‭conquer‬‭en‬‭anglais)‬‭:‬‭il‬‭consiste‬
‭à‬ ‭ramener‬ ‭la‬ ‭résolution‬ ‭d’un‬ ‭problème‬ ‭dépendant‬ ‭d’un‬ ‭entier‬ ‭n‬ ‭à‬ ‭la‬ ‭résolution‬ ‭de‬ ‭un‬ ‭ou‬ ‭plusieurs‬
‭0‬
‭sous-problèmes‬‭identiques‬‭portant‬‭sur‬‭des‬‭entiers‬ ‭n‬ ‭≈‬‭α‭n
‬ ‬ ‭avec‬ ‭α‬‭<‬ ‭1‬‭(le‬‭plus‬‭souvent,‬‭on‬‭aura‬‭α‬‭=‬‭1‭/‬‬‭2).‬‭Par‬
‭n‬ ‭b‭n
‬ /‬‭2c‬ ‭2‬
‭exemple, l’algorithme‬‭d’exponentiation rapide ramène‬‭le calcul de‬‭x‬ ‭au calcul de‬‭y‬ ‭avec‬‭y‬‭=‬‭x‬ ‭.‬

http://info-llg.fr‬

‭8.2 option informatique‬

‭ n‬‭autre‬‭exemple‬‭classique‬‭d’utilisation‬‭de‬‭ce‬‭paradigme‬‭est‬‭l’algorithme‬‭de‬‭recherche‬‭dichotomique‬‭:‬‭étant‬
U
‭donné‬‭un‬‭tableau‬‭trié‬‭par‬‭ordre‬‭croissant‬‭d’entiers,‬‭comment‬‭déterminer‬‭si‬‭un‬‭élément‬‭appartient‬‭ou‬‭pas‬‭à‬‭ce‬
‭tableau ?‬
‭Le principe est bien connu : on compare l’élément recherché à l’élément médian, et le cas échéant on répète‬
‭la‬‭recherche dans la partie gauche ou droite du tableau.‬

‭x < m m x > m‬

‭i k j‬

let‬‭
‭ recherche_dicho x t =‬
let rec‬‭
‭ aux i j =‬
if‬‭
‭ j < i‬‭then‬‭false‬
else match‬‭
‭ (i + j) / 2‬‭
with‬
| k when x = t.(k)‬‭−‭
‭ >
‬ true‬
| k when x < t.(k)‬‭−‭
‭ >
‬ aux i (k‬
‭−‭
1
‬ )‬
| k‬‭−‬‭
‭ > aux (k+1) j‬
in‬‭
‭ f 0 (vect_length t‬‭−‬‭1) ;;‬

‭Notons‬‭c‭n‬ ‬‭le nombre de comparaisons nécessaires entre‬‭x‬‭et un élément du tableau de taille‬‭n‬‭dans le pire‬
‭des cas (correspondant au cas où‬‭x‬‭est supérieur à‬‭tous les éléments du tableau). Nous avons‬‭c‬‭0‬‭= 0‬‭et‬‭c‬‭n‬‭= 2‬
‭+‭c
‬ ‬‭b‭n‬ /‬‭2c‬‭pour‬
‭j‬‭n‬
‭n‬‭>‬‭1. Si on introduit de nouveau l’écriture binaire‬‭de‬‭n‬‭:‬‭n‬‭= [‬‭b‭p‬ ‬‭,b‬‭p‬‭−1‬‭,‬‭···‬‭,b‬‭0‭]‬ ‭2‬ ‭,‬ nous avons‬ ‭2‭k‬ ‬‭= [‬‭b‭p‬ ‬‭,b‬‭p‬‭−1‬‭,‭·‬ ··‬
‭,b‬‭1‭]‬ ‭2‬ ‭,‬ ‬‭et il est alors facile d’en déduire que‬‭c‬‭n‬‭= 2‬‭p‬‭+ 2 = 2blog‬‭n‬‭c + 2.‬

‭1.3 Étude générale du coût‬


‭En général, les algorithmes suivant le paradigme‬‭diviser‬‭pour régner‬‭partagent un problème de taille‬‭n‬‭en‬
‭j‬‭n‬ ‭k‬ ‭l‬‭n‬ ‭m‬
‭deux‬‭sous-problèmes de tailles respectives‬ ‭2‬ ‭et‬ ‭2‬ ‭et conduisent à une relation de récurrence de‬‭la‬
‭forme :‬

‭c‭n‬ ‬‭=‬‭ac‬‭b‭n‬ /‬‭2c‬‭+‬‭bc‬‭d‭n‬ /‬‭2e‬


‭avec‬‭a‬‭+‬‭b‬‭> 1,‬
‭d‬‭n‬

‭d‭n‬ ‬‭représentant le coût du partage et de la recomposition‬‭du problème et‬‭c‬‭n‬‭le coût total.‬

‭ ous allons faire une étude générale de ces relations de récurrence en commençant par traiter le cas où‬‭n‬
N
‭est‬‭une puissance de 2 : posons‬‭n‬‭= 2‬‭p‬‭et‬‭u‭p‬ ‬‭=‬‭c‬‭2‭p‬ ‬‭. La relation de récurrence devient :‬‭u‭p‬ ‬‭= (‬‭a‬‭+‬‭b‭)‬ ‭u
‬ ‬‭p‭−‬ 1‬‭+‬‭d‭2‬ ‭p‬ ‬‭,‬
‭soit :‬

‭p‬
‭(‭a
‬ ‬‭+‬‭b‭)‬ ‬ =
‭ ‭u
‬ ‭p‬ ‭−‬ 1‬
‭u‭p‬ ‬ ‭p‬
‭+‬‭b‭)‬ ‬ ‭.‬
‭(‭a
‬ ‬‭+‬
‭p‬‭−1‬
‭b‭)‬ ‬ ‭+‭d
‬ ‭2‬ ‭p‬ ‬‭(‬‭a‬

‭e on‬ ‭p‬ ‭p‬


‭ ar‬
P ‭= (‬‭a‬‭+‬‭b‬‭)‬ ‭u‭0‬ ‬‭+‬ ‭X‬ ‭j‬‭=1‬
‭télescopag‬‭obtient :‬‭u‬‭p‬
‭j‬ ‭.‬
‭d‬‭2‭j‬‬ ‭(‬‭a‬‭+‬‭b‭)‬ ‬

‭Pour poursuivre ce calcul, il est nécessaire de préciser la valeur de‬‭d‭n‬ ‭.‬ Nous allons supposer que le coût‬‭de‬
‭k‬
‭la‬‭décomposition et de la recomposition est polynomial‬‭(au sens large), ce qui permet de poser‬‭d‭n‬ ‬‭=‬‭λ‭n ‬ ‬ ‭.‬
‭Nous‬
‭avons alors :‬ ‭p‬ ‭k‬
‭X‬ ‭j‭=‬ 1‬ ‭+‬‭b‬‭, 2‬ ‭(‭u ‬ ‬‭0‬‭+‬
‭u‬‭0‬‭+ λ‬ !
‭ ‬ 
‭ ‬ ‭p‬
‭λ‬‭p‭)‬ (‬‭a‬‭+‬‭b‭)‬ ‬ ‭si‬‭a‬‭+‬
‭p‬ ‭j‬ ‭=‬ ‭‭α
‬ 2‬
‭u‬‭p‬‭= (‬‭a‬‭+‬‭b‭)‬ ‬ ‭k‬ ‭k‬
‭+ β(‬‭a‬‭+‬‭b‬‭)‬ ‭si‬‭a‬‭b‬‭= 2‬
‭2‬ ‭a‬‭+‬‭b‬ ‭kp‬ ‭p‬

‭k‬ ‭et β =‬‭u‬‭0‬‭−‬ ‭.‬


‭en ayant‬ ‭2‬
‭λ‬ ‭k‬
‭posé α = λ‬‭2‬‭k‬‭−‬‭a‬‭−‬‭b‬ ‭2‬ ‭−‬‭a‬‭−‬‭b‬
‭k‬
‭2‬

‭Trois cas se présentent alors :‬


‭k‬ ‭kp‬
‭– si‬‭a‬‭+‬‭b <‬‭2‬ ‭,‬‭u‬‭p‬‭∼ α2‬ ‭;‬
‭k‬ ‭p‬ ‭kp‬
‭– si‬‭a‬‭+‬‭b‬‭= 2‬ ‭,‬‭u‬‭p‬‭∼ λ‬‭p‬‭(‭a
‬ ‬‭+‬‭b‬‭)‬ ‭= λ‬‭p‬‭2‬ ‭;‬
‭k‬ ‭p‬
‭ si‬‭a‬‭+‬‭b >‬‭2‬ ‭,‬‭u‬‭p‬‭∼ β(‬‭a‬‭+‬‭b‬‭)‬ ‭.‬

‭Pour traiter le cas général d’un entier‬‭n‬‭quelconque,‬‭nous allons maintenant prouver le résultat suivant :‬
‭Diviser pour régner 8.3‬

‭Lemme. —‬‭Lorsque la suite‬‭(‭d


‬ ‬‭n‭)‬ ‭n‬ ‬‭∈N‬‭est croissante,‬‭la suite‬‭(‭c‬ ‬‭n‭)‬ ‭n‬ ‭∈‬ N‬‭l’est aussi.‬
‭∗‬
‭Preuve.‬‭Montrons par récurrence sur‬‭n‬‭∈ N‬ ‭que‬‭c‭n‬ ‬‭6‬‭c‭n‬ ‬‭+1‬‭.‬
‭ Lorsque‬‭n‬‭= 1, on a :‬‭c‬‭2‬‭= (‬‭a‬‭+‬‭b‬‭)‭c‬ ‭1‬ ‬‭+‬‭d‬‭1‬‭>‬‭c‭1‬ ‬‭car‬‭a‬‭+‬‭b‬‭> 1 et‬‭d‬‭1‬‭> 0.‬

‭– Si‬‭n >‬‭1, on suppose le résultat acquis jusqu’au‬‭rang‬‭n‬‭− 1. On a alors :‬

‭c‬‭n‭+‬ 1‬‭−‬‭c‬‭n‬‭=‬‭a‭(‬ ‭c‬ ‬‭d(‬‭n‬‭+1)‬‭/‭2‬ e‬‭−‬‭c‭d‬ ‬‭n/‬‭2e‬‭) +‬‭b‬‭(‬‭c‭b‬ (‬‭n‭+‬ 1)‬‭/‬‭2c‬‭−‬‭c‭b‬ ‭n‬ /‬‭2c‬‭) +‬‭d‬‭n‭+‬ 1‬‭−‬‭d‭n‬ ‬‭> 0‬

‭ce qui achève la démonstration.‬

‭p‬
‭Lorsque‬ ‭cette‬ ‭condition‬‭est‬‭satisfaite,‬‭on‬‭peut‬‭encadrer‬ ‭n‬ ‭par‬‭deux‬‭puissances‬‭consécutives‬‭de‬‭2‬‭:‬‭2‬ ‭6‬‭n‬‭<‬
‭p‬‭+1‬ ‭k‬
‭2‬ ‭,‬‭avec‬ ‭p‬ ‭=‬ ‭blog‬‭n‬‭c‭,‬‬‭ce‬‭qui‬‭conduit‬‭à‬ ‭u‭p‬ ‬ ‭6‬‭c‭n‬ ‬ ‭6‬‭u‬‭p‬‭+1‬‭.‬‭Lorsque‬ ‭d‬‭n‬ ‭=‬ ‭λ‬‭n‬ ‭,‬‭les‬‭résultats‬‭précédents‬‭permettent‬
‭ ’établir‬‭la règle suivante (connue sous le nom de‬‭théorème maître‬‭) :‬
d

‭k‬
‭Théorème. —‬‭Lorsque a‬‭+‬‭b >‬‭1‬‭, la suite‬‭(‭d
‬ ‭n‬ ‬‭)‭n‬ ‭∈‬ N‬‭croissante‬‭et d‬‭n‬‭= Θ(‬‭n‬ ‭)‬‭, on a :‬
‭k‬
‭si‬‭log(‬‭a‬‭+‬‭b‬‭)‬‭< k, c‬‭n‬‭= Θ(‬‭n‬ ‭)‬‭;‬
‭si‬‭log(‬‭a‬‭+‬‭b‬‭) =‬‭k, c‬‭n‬‭=‬
‭k‬
‭Θ(‬‭n‬ ‭log‬‭n‭)‬ ‬‭; si‬‭log(‬‭a‬‭+‬‭b‬‭)‬‭> k,‬
‭log(‬‭a‭+
‬ ‬‭b‭)‬ ‬
‭c‬‭n‬‭= Θ(‬‭n‬ ‭)‬‭.‬

‭ ous utiliserons désormais ce résultat pour évaluer rapidement le coût d’une méthode suivant le principe‬
N
‭diviser pour régner‬‭.‬

‭2. Exemples d’algorithmes « diviser pour régner »‬


‭2.1 Tri fusion‬
‭ n‬‭appelle‬‭algorithme‬‭de‬‭tri‬‭tout‬‭algorithme‬‭permettant‬‭de‬‭trier‬‭les‬‭éléments‬‭d’un‬‭tableau‬‭ou‬‭d’une‬‭liste‬‭selon‬
O
‭un‬ ‭ordre‬ ‭déterminé.‬ ‭On‬ ‭peut‬ ‭distinguer‬ ‭parmi‬ ‭ceux-ci‬ ‭ceux‬ ‭qui‬ ‭procèdent‬ ‭par‬ ‭comparaison‬ ‭entre‬ ‭paires‬
‭d’éléments‬‭;‬ ‭dans‬‭ce‬‭cas,‬‭on‬‭adopte‬‭en‬‭général‬‭comme‬‭élément‬‭de‬‭mesure‬‭de‬‭la‬‭complexité‬‭le‬‭nombre‬‭de‬
c‭ omparaisons‬‭effectuées‬‭en‬‭fonction‬‭de‬‭la‬‭taille‬‭n‬‭du‬‭tableau‬‭(mais‬‭ce‬‭n’est‬‭pas‬‭forcément‬‭le‬‭seul‬‭paramètre‬
‭à‬‭prendre‬‭en‬ ‭compte).‬‭Les‬‭algorithmes‬‭naïfs‬‭(tri‬‭par‬‭sélection‬‭ou‬‭par‬‭insertion‬‭par‬‭exemple)‬‭ont‬‭un‬‭coût‬‭dans‬
‭2‬
‭le pire des cas‬‭en O(‬‭n‬ ‭). Nous allons montrer qu’il‬‭est possible de faire mieux.‬

‭Appelé‬ ‭merge‬ ‭sort‬ ‭en‬ ‭anglais,‬ ‭le‬ ‭tri‬ ‭fusion‬ ‭adopte‬ ‭une‬ ‭approche‬ ‭«‬ ‭diviser‬ ‭pour‬ ‭régner‬ ‭»‬ ‭:‬ ‭on‬ ‭partage‬ ‭le‬
‭j‬‭n‬ ‭k‬ ‭l‬‭n‬ ‭m‬
‭tableau‬ ‭en‬‭deux‬‭parties‬‭de‬‭tailles‬‭respectives‬ ‭2‬ ‭et‬ ‭2‬ ‭que‬‭l’on‬‭trie‬‭par‬‭un‬‭appel‬‭récursif,‬‭puis‬‭on‬‭fusionne‬
‭les deux‬‭parties triées.‬

‭– scission du tableau en deux parties :‬

‭– tri des deux moitiés du tableau :‬

‭partie triée partie triée‬

‭– fusion des parties triées :‬

‭tableau trié‬
I‭l‬‭est‬‭raisonnable‬‭de‬‭penser‬‭que‬‭la‬‭scission‬‭et‬‭la‬‭fusion‬‭ont‬‭un‬‭coût‬‭linéaire‬‭(ce‬‭sera‬‭vérifié‬‭plus‬‭loin),‬‭et‬‭que‬
‭par‬ ‭voie‬ ‭de‬ ‭conséquence‬ ‭la‬ ‭relation‬ ‭de‬ ‭récurrence‬ ‭satisfaite‬ ‭par‬ ‭le‬ ‭nombre‬ ‭c‭n‬ ‬ ‭de‬ ‭comparaisons‬ ‭est‬ ‭de‬ ‭la‬
‭forme :‬‭c‭n‬ ‬‭=‬‭c‭b‬ ‭n‬ /‬‭2c‬‭+‬‭c‬‭d‭n‬ /‬‭2e‬‭+ Θ(‬‭n‬‭). Le théorème maître‬‭montre que dans ces conditions‬‭c‬‭n‬‭= Θ(‬‭n‭l‬og‬‭n‭)‬ .‬

http://info-llg.fr‬

‭8.4 option informatique‬

‭ ependant,‬‭une‬‭difficulté‬‭se‬‭présente‬‭lorsqu’on‬‭cherche‬‭à‬‭implémenter‬‭cet‬‭algorithme‬‭avec‬‭des‬‭vecteurs‬‭:‬‭il‬
C
‭est‬ ‭difficile‬‭de‬‭fusionner‬‭deux‬‭demi-tableaux‬‭sur‬‭place,‬‭c’est‬‭à‬‭dire‬‭en‬‭s’autorisant‬‭uniquement‬‭la‬‭permutation‬
‭de‬‭deux‬‭éléments‬‭(ce‬‭n’est‬‭pas‬‭impossible,‬‭mais‬‭ou‬‭bien‬‭lent,‬‭ou‬‭bien‬‭compliqué‬‭à‬‭mettre‬‭en‬‭œuvre).‬‭Mettre‬
‭en‬‭œuvre cet algorithme sur une liste est mieux adapté.‬
‭On choisit de scinder les éléments de la liste suivant la parité de leur indice :‬

let
‭ rec‬‭scission =‬‭function‬
|
‭ []‬‭−‭
>
‬ [], []‬
|
‭ [a]‬‭−‭
>
‬ [a], []‬
|
‭ a::b::q‬‭−‬‭
>‬‭
let‬‭
(l1, l2) = scission q‬‭
in‬‭
a::l1, b::l2‬‭
;;‬

‭La fusion de deux listes triées ne pose aucun problème :‬

let
‭ rec‬‭
fusion =‬‭ fun‬
|
‭ [] l2‬‭−‬‭
> l2‬
|
‭ l1 []‬‭−‬‭
> l1‬
|
‭ (t1::q1) l2 when t1 < hd l2‬‭−‬‭
> t1::(fusion q1 l2)‬
|
‭ l1 (t2::q2)‬‭−‬‭
> t2::(fusion l1 q2) ;;‬

‭Il reste à rédiger l’algorithme de tri fusion proprement dit :‬

let
‭ rec‬‭merge_sort =‬‭ function‬
|
‭ []‬‭−‭>
‬ []‬
|
‭ [a]‬‭−‭>
‬ [a]‬
|
‭ l‬‭−‭
>
‬ ‬‭
let‬‭(l1, l2) = scission l‬‭
in‬
fusion (merge_sort l1) (merge_sort l2) ;;‬

‭2.2 Distance minimale‬


I‭ntéressons nous maintenant au problème de la recherche des deux points les plus proches dans un nuage‬
‭p‭1‬ ‬‭= (‬‭x‬‭1‭,‬ y‬‭1‬‭)‬‭, p‬‭2‬‭= (‬‭x‬‭2‭,‬ y‬‭2‭)‬ ‭,‬..., p‬‭n‬‭= (‬‭x‬‭n‭,‬ y‬‭n‬‭) de points‬‭distincts du plan. L’algorithme naïf consiste à calculer la‬
‭n‬
‭distance entre toutes les paires possibles et d’en extraire le minimum. Sachant qu’il y en a‬ ‭2‬ ‭, ceci conduit à‬
‭un‬‭algorithme de coût quadratique. Peut-on faire mieux‬‭en adoptant une stratégie diviser pour régner ?‬

‭ vant‬ ‭toute‬ ‭chose,‬‭nous‬‭allons‬‭avoir‬‭besoin‬‭d’ordonner‬‭ces‬‭points‬‭par‬‭abscisse‬‭croissante,‬‭mais‬‭aussi‬‭par‬


A
‭0‬
‭ordonnée‬ ‭croissante.‬ ‭Nous‬ ‭allons‬ ‭donc‬ ‭calculer‬ ‭deux‬ ‭tableaux‬ ‭P‬ ‭et‬ ‭P‬ ‭,‬ ‭le‬ ‭premier‬ ‭contenant‬ ‭les‬ ‭points‬
‭classés‬ ‭par‬‭ordre‬‭croissant‬‭des‬‭abscisses,‬‭et‬‭le‬‭second‬‭par‬‭ordre‬‭croissant‬‭des‬‭ordonnées.‬‭D’après‬‭la‬‭section‬
‭précédente,‬‭nous savons que ceci peut être exécuté‬‭en Θ(‬‭n‬‭log‬‭n‭)‬ .‬
‭Nous allons désormais supposer P = (‬‭p‭1‬ ‭,‬ p‬‭2‬‭,..., p‬‭n‭)‬ ‬‭avec‬‭x‬‭1‬‭6‬‭x‬‭2‬‭6 ··· 6‬‭x‭n‬ ‭.‬ ‬

‭d‭2‬ ‬

‭d‭1‬ ‬

‭m‬
‭δ‬
‭Diviser pour régner 8.5‬

‭Séparons‬‭alors‬‭les‬‭points‬‭de‬ ‭P‬ ‭en‬‭deux‬‭parties‬‭sensiblement‬‭égales‬ ‭P‭1‬ ‬ ‭=‬ ‭{‭p


‬ ‭1‬ ‬‭,‬‭p‬‭2‭,‬ ...,‬‭p‬‭k‭}‬ ‬‭et‬‭P‬‭2‬‭=‬‭{‭p
‬ ‬‭k‭+‬ 1‬‭,...,‬‭p‭n‬ ‭−‬ 1‬‭,‬
‭p‬‭n‭}‬ ‭,‬‬ ‭avec‬ ‭k‬ ‭=‬ ‭b‭n
‬ /‬‭2‭c‬ ‬‭,‬‭et‬‭notons‬‭d‭1‬ ‬‭et‬‭d‬‭2‬‭les‬‭distances‬‭minimales‬‭entre‬‭respectivement‬‭deux‬‭points‬‭de‬‭P‭1‬ ‬‭et‬‭deux‬
‭ oints‬‭de P‬‭2‭.‬ ‬
p
‭Trois cas sont possibles pour la distance minimale‬‭d‬‭entre deux points de P :‬
‭1. elle est atteinte entre deux points de P‬‭1‭,‬ auquel‬‭cas‬‭d‬‭=‬‭d‬‭1‬‭;‬
‭2. elle est atteinte entre deux points de P‬‭2‭,‬ auquel‬‭cas‬‭d‬‭=‬‭d‬‭2‬‭;‬
‭3. elle est atteinte entre un point de P‬‭1‬‭et un point‬‭de P‬‭2‭.‬ ‬
‭ e‬‭calcul‬‭de‬ ‭δ‬ ‭=‬ ‭min‬‭(‭d
L ‬ ‭1‬ ‬‭,‬‭d‭2‬ ‬‭)‬‭permet‬‭d’éliminer‬‭l’un‬‭ou‬‭l’autre‬‭des‬‭deux‬‭premiers‬‭cas.‬‭Et‬‭dans‬‭le‬‭troisième‬‭cas,‬
‭les‬ ‭deux‬‭points‬‭que‬‭nous‬‭recherchons‬‭se‬‭trouvent‬‭dans‬‭la‬‭bande‬‭verticale‬‭délimitée‬‭par‬‭les‬‭abscisses‬‭m‬‭−‬‭δ‬
‭et‬‭m‬‭+‬‭δ‬‭avec‬‭m‬‭=‭x
‬ ‬‭k‬‭+‬‭x‬‭k‬‭+1‬

‭ ‬‭.‬
2
‭00‬ ‭0‬ ‭0‬
‭ ous‬ ‭pouvons‬ ‭en‬ ‭coût‬ ‭linéaire‬ ‭déterminer‬ ‭les‬ ‭points‬ ‭P‬ ‭=‬ ‭(‬‭p‬ ‭i‬‭,...,‬ ‭p‬ ‭j‭)‬ ‬ ‭de‬ ‭cette‬ ‭bande‬ ‭verticale‬ ‭en‬ ‭les‬
N
‭0‬ ‭0‬
‭ rdonnant‬ ‭par‬‭ordonnée‬‭croissante‬‭à‬‭l’aide‬‭du‬‭tableau‬ ‭P‬ ‭(il‬‭suffit‬‭de‬‭parcourir‬‭une‬‭fois‬‭P‬ ‭en‬‭ne‬‭gardant‬‭que‬
o
‭les points‬‭dont les abscisses sont comprises entre‬‭m‬‭− δ et‬‭m‬‭+ δ).‬
‭Pour conclure, il reste à observer (c’est le point crucial) que dans chaque tranche de hauteur‬‭δ‬‭de‬‭cette bande‬
‭ne‬‭peuvent se trouver qu’‬‭au plus‬‭sept points :‬

‭δ‬

‭m‬
‭δ‬
‭ n effet, s’il en existait huit, il y en aurait deux au moins appartenant tout deux à‬‭P‬‭1‬‭ou tous deux à‬‭P‭2‬ ‬‭et à‬
E
‭une‬‭distance strictement inférieure à δ.‬
‭Cette remarque permet de restreindre la recherche de la distance minimale entre deux points de‬‭P‬‭00‬‭en‬‭se‬
‭restreignant aux points distants au plus de sept cases de ce tableau, ce qui conduit à un coût linéaire.‬‭En‬
‭0‬
‭définitive, le coût de cet algorithme (sans compter le pré-traitement des tableaux‬‭P‬‭et‬‭P‬ ‭) vérifie une‬‭relation‬
‭de récurrence de la forme :‬‭c‬‭n‬‭=‬‭c‬‭b‭n‬ /‬‭2c‬‭+‬‭c‬‭d‬‭n/‬‭2e‬‭+‬‭Θ(‬‭n‬‭), ce qui prouve que‬‭c‭n‬ ‬‭= Θ(‬‭n‭l‬og‬‭n‭)‬ .‬

‭3. Multiplication rapide‬


‭ ans cette section, nous allons appliquer la paradigme « diviser pour régner » au calcul d’un produit, d’abord‬
D
‭de deux polynômes, puis de deux entiers, et enfin de deux matrices.‬

‭3.1 Multiplication de deux polynômes‬


‭n‬ ‭k‬
‭X‬ ‭k‬‭=0‬ ‭ ‭k‬ ‬‭X‬ ‭∈ Z[X] par le tableau (de‬
a
‭ ous choisissons de‬
N ‭taille‬‭n‬‭+ 1) :‬
‭représenter le polynôme P =‬

‭a‭0‬ ‬‭a‬‭1‬‭a‭2‬ ‬‭a‬‭n‭−‬ 1‬‭a‭n‬ ‬

‭(‭a
‬ ‬‭k‬‭étant stocké dans la case d’indice‬‭k‭)‬ , de sorte‬‭de pouvoir accéder à chaque coefficient avec un coût‬
‭constant.‬
‭n‬ ‭k‬
X
‭ ‬ ‭k‬‭=0‬
‭a‬‭k‭X
‭k‬ ‭n‬ ‭(‬‭a‬‭k‬‭+‬‭b‭k‬ ‬‭)‬‭X‬ ‭montre‬ ‭degré‬‭n‬‭nécessite‬
‭La formule‬ ‬ ‬ ‭+‬‭X‬ ‭k‬‭=0‬
‭que l’addition de‬
‭k‬ ‭n‬
‭b‬‭k‭X ‬
‬ ‭=‬ X
‭ ‬ k
‭ ‬
=
‭ 0‬ ‭deux polynômes de‬

‭n‬‭+ 1 additions (donc un coût linéaire).‬


let‬‭
‭ som p q =‬
let‬‭
‭ n = vect_length p‬‭−‬‭
1‬‭in‬
let‬‭
‭ r = make_vect (n + 1) 0‬‭ in‬
for‬‭
‭ i = 0‬‭
to‬‭
n‬‭
do‬‭
r.(i) <‬ p.(i) + q.(i)‬‭
‭−‬‭ done‬‭
;‬
r ;;‬

http://info-llg.fr‬

‭8.6 option informatique‬
‭ roduit, la‬ ‭n‬
p ‭n‬ ‭n‬ ‭ ontre‬ ‭l’aide de‬
m
‭X‬ ‭i‬‭=0‬
‭n‬
‭X‬ ‭j‬‭=0‬ ‭X‬ ‭i‬‭=0‬ ‭X‬ ‭j‭=
‬ 0‬
‭i‬ ‭j‬
‭formule‬ ‭a‬‭i‭X
‬ ‬ ‭b‬‭j‭X
‬ ‬ ‭qu’il peut‬
‭être‬
‭Quant au‬ ‭i‭+
‬ ‭j‬‬
‭×‬ ‭=‬ ‭a‭i‬‭b
‬ ‬‭j‭X
‬ ‬ ‭réalisé à‬

‭2‬ ‭2‬
‭n‬ ‭additions et (‬‭n‬‭+ 1)‬ ‭multiplications (donc un coût‬‭quadratique).‬

let‬‭
‭ prod p q =‬
let‬‭
‭ n = vect_length p‬‭−‬‭ 1‬‭
in‬
let‬‭
‭ r = make_vect (2 * n + 1) 0‬‭ in‬
for‬‭
‭ i = 0‬‭to‬‭n‬‭ do‬
for‬‭
‭ j = 0‬‭
to‬‭ n‬‭do‬
r.(i+j) <‬
‭ r.(i+j) + p.(i) * q.(j)‬
‭−‬‭
done‬‭
‭ ;‬
done‬‭
‭ ;‬
r ;;‬

‭ n convient généralement qu’une addition est beaucoup rapide à effectuer qu’un produit ; nous allons donc‬
O
‭chercher à réduire le nombre de multiplications, quitte à faire plus d’additions. (Il faut cependant savoir que‬
‭ceci était surtout vrai dans les temps anciens de l’informatique ; c’est beaucoup moins vrai aujourd’hui.)‬‭Pour‬
‭l‬‭n‬ ‭m‬
‭appliquer le paradigme « diviser pour régner », nous allons poser‬‭m‬‭=‬ ‭2‬ ‭puis‬‭P‬‭=‬‭X‬‭m‭P
‬ ‭m‬
‬‭1‬‭+‬‭P‬‭2‬‭et‬‭Q‬‭=‬‭X‬ ‭Q‭1‬ ‬‭+‬
‭j‬‭n‬ ‭k‬
‭Q‭2‬ ‭,‬ le degré de chacun des quatre polynômes P‬‭1‬‭, P‬‭2‭,‬ Q‬‭1‬‭et Q‬‭2‬‭étant inférieur ou égal à‬ 2 ‭ ‬ ‭. Ainsi, PQ =‬
‭2‬‭m‬ ‭m‬
‭X‬ ‭P‬‭1‭Q ‬ ‬‭+ X‬ ‭(P‬‭1‬‭Q‭2‬ ‬‭+ P‬‭2‬‭Q‭1‬ ‭)‬ + P‬‭2‬‭Q‭2‬ ‭.‬ ‬
‬ ‭1

‭ uisqu’on‬ ‭accède‬ ‭aux‬ ‭coefficients‬ ‭de‬ ‭chaque‬ ‭polynôme‬ ‭avec‬ ‭un‬ ‭coût‬ ‭constant,‬ ‭il‬ ‭n’y‬ ‭a‬ ‭pas‬ ‭de‬ ‭coût‬ ‭de‬
P
‭décomposi‬ ‭tion.‬ ‭4‬ ‭appels‬ ‭récursifs‬ ‭sont‬ ‭nécessaires,‬ ‭et‬ ‭la‬ ‭recomposition‬ ‭nécessite‬ ‭3‬ ‭additions‬ ‭de‬ ‭coût‬
‭linéaire. Le nombre‬‭de multiplications vérifie donc‬‭la relation :‬

‭c‭n‬ ‬‭= 4‬‭c‭b‬ ‭n‬ /‬‭2c‬‭+ Θ(‬‭n‬‭)‭.‬‬

‭2‬
‭ e théorème maître nous permet dès lors d’affirmer que‬‭c‭n‬ ‬‭=‬‭Θ‭(‬ ‬‭n‬ ‭), ce qui n’est pas meilleur que l’algorithme‬
L
‭naïf. Nous n’avons donc pour l’instant rien gagné à mettre en œuvre le paradigme « diviser pour régner ».‬

‭En revanche, si on observe que : P‬‭1‭Q


‬ ‬‭2‬‭+ P‬‭2‭Q
‬ ‬‭1‬‭= (P‬‭1‬‭+ P‬‭2‭)‬ (Q‬‭1‬‭+ Q‬‭2‭)‬ − P‬‭1‭Q
‬ ‬‭1‬‭− P‬‭2‭Q ‬ ‬‭, on a alors :‬
‬ ‭2

‭2‭m
‬ ‬ ‭m‬
‭PQ = X‬ ‭R‬‭1‬‭+ X‬ ‭(R‬‭2‬‭− R‬‭1‬‭− R‬‭3‭)‬ +‬ ‭avec R‬‭1‬‭= P‬‭1‭Q
‬ ‬‭1‭,‬ ‬‭R‭2
‬ ‬‭= (P‬‭1‬‭+ P‬‭2‭)‬ (Q‬‭1‬‭+ Q‬‭2‭)‬ ‭,‬‬‭R‭3‬ ‬‭=‬
‭R‬‭3‬ ‭P‭2‬ ‭Q
‬ ‬‭2‭,‬ ‬

‭et il n’est plus nécessaire que d’utiliser 3 appels récursifs. La relation de récurrence prend cette fois la forme‬

‭:‬‭c‬‭n‬‭= 3‬‭c‬‭b‭n‬ /‬‭2c‬‭+ Θ(‬‭n‭)‬ ‬

‭log 3‬
‭qui conduit à‬‭c‭n‬ ‬‭= Θ(‬‭n‬ ‭) (avec log 3 ≈ 1‬‭,‬‭585).‬

‭Cette méthode porte le nom d’algorithme de Karatsuba ; elle a été publiée pour la première fois en 1962.‬

‭• Mise en œuvre pratique.‬

‭Pour‬ ‭faciliter‬ ‭la‬ ‭mise‬ ‭en‬ ‭œuvre,‬ ‭on‬ ‭suppose‬ ‭que‬ ‭les‬ ‭polynômes‬ ‭sont‬ ‭stockés‬ ‭dans‬ ‭des‬ ‭tableaux‬ ‭de‬ ‭taille‬
‭k‬ ‭k‬
‭ ‬ ‭(quitte‬ ‭à‬ ‭rajouter‬ ‭des‬ ‭0),‬ ‭donc‬ ‭de‬ ‭degré‬ ‭inférieurs‬ ‭ou‬ ‭égaux‬‭à‬‭2‬ ‭−‭1
2 ‬ .‬‭La‬‭fonction‬‭qui‬‭suit‬‭devra‬‭donc‬‭être‬
‭précédée‬‭d’une‬ ‭fonction‬‭«‬‭normalisant‬‭»‬‭les‬‭polynômes,‬‭et‬‭suivie‬‭d’une‬‭fonction‬‭simplifiant‬‭le‬‭résultat‬‭(c’est‬‭à‬
‭dire enlevant les‬‭zéros redondants).‬
‭Diviser pour régner 8.7‬

let rec‬‭
‭ prod p q =‬
match‬‭
‭ (vect_length p)‬‭ with‬
| 1‬‭−‭
‭ >
‬ [| p.(0)*q.(0) ; 0 |]‬
| n‬‭−‭
‭ >
‬ ‬‭
let‬‭
m = n / 2‬‭ in‬
let‬‭
‭ p1 = sub_vect p m m‬‭ and‬‭
p2 = sub_vect p 0 m‬‭
in‬
let‬‭
‭ q1 = sub_vect q m m‬‭ and‬‭
q2 = sub_vect q 0 m‬‭
in‬
let‬‭
‭ r1 = prod p1 q1‬‭ and‬‭
r2 = prod (som p1 p2) (som‬‭q1 q2)‬
and‬‭
‭ r3 = prod p2 q2‬‭ in‬
let‬‭
‭ s = make_vect (2*n) 0‬‭ in‬
for‬‭
‭ i = 0‬‭ to‬‭ n‬‭−‬‭
1‬‭
do‬
s.(n+i) <‬
‭ ‭−‬‭s.(n+i) + r1.(i) ;‬
s.(m+i) <‬
‭ s.(m+i) + r2.(i)‬‭−‬‭
‭−‬‭ r1.(i)‬‭−‬‭
r3.(i) ;‬
s.(i) <‬
‭ s.(i) + r3.(i)‬
‭−‬‭
done‬‭
‭ ;‬
s ;;‬

‭3.2 Multiplication de deux entiers‬


‭n‭−
‬ 1‬ ‭Les entiers que nous allons considérer sont des‬
‭X‬
‭entiers codés en base 2 sur‬‭n‬‭bits :‬‭x‬‭=‬‭k‭=‬ 0‬ ‭k‬
‭x‬‭k‭2
‬ ‬ ‭, que nous‬

r‭ eprésenterons‬ ‭par‬ ‭des‬ ‭vecteurs‬ ‭à‬ ‭n‬ ‭composantes.‬ ‭La‬ ‭similitude‬ ‭qui‬ ‭existe‬ ‭avec‬ ‭les‬ ‭polynômes‬ ‭va‬ ‭nous‬
‭permettre‬‭d’adapter‬‭les‬‭algorithmes‬‭précédents‬‭aux‬‭entiers,‬‭la‬‭seule‬‭différence‬‭consistant‬‭dans‬‭la‬‭gestion‬‭de‬
‭la propagation‬‭de la retenue.‬
‭n‭−
‬ 1‬ ‭X‭n‬ ‭−‬ 1‬ ‭de longueur‬‭n‬‭+ 1 défini‬
‭X‬ ‭i‬‭=0‬ ‭x‬‭i‭2
‭i‬
‭Si‬‭x‬‭=‬ ‬ ‬‭et‬‭y‬‭=‬ ‭i‬‭=0‬
‭par les‬
‭i‬
‭y‬‭i‭2
‬ ‬‭, alors‬‭s‬‭=‬‭x‬‭+‬‭y‬‭va être‬
‭représenté par un vecteur‬
‭L’algorithme naïf du produit correspond au‬
‭relations :‬
‭développement :‬‭xy‬‭=‬‭i‭=‬ 0‬
‭–‬‭r‬‭0‬‭= 0 ;‬ ‭(‬‭x‭2 ‭i‬
‬ ‬‭)‭y‬ ‬‭, qui se ramène à‬‭n‬‭additions‬
‭i‬
‭– ∀‬‭i‬‭∈ ~0‬‭,n‬‭− 1,‬‭s‬‭i‬‭= (‬‭r‭i‬‬‭+‬‭x‬‭i‬‭+‬‭y‬‭i‬‭) mod 2 ;‬
‭– ∀‬‭i‬‭∈ ~0‬‭,n‬‭− 1,‬‭r‭i‬‬‭+1‬‭= (‬‭r‭i‬‬‭+‬‭x‬‭i‬‭+‬‭y‭i‬‬‭)‬‭/‭2
‬ ;‬
‭–‬‭s‬‭n‬‭=‬‭r‬‭n‭.‬ ‬

‭ ù‬‭r‬‭i‭r‬ eprésente la retenue entrante correspondant‬‭à la‬


o
‭position‬‭i‬‭. Le coût d’une addition est donc un Θ(‬‭n‬‭).‬

‭n‭−
‬ 1‬
‭X‬

‭ ’entiers de longueur 2‬‭n‬‭, puisqu’une multiplication‬‭par 2 s’obtient en représentation binaire par simple‬
d
‭2‬
‭décalage. Ceci donne un coût en Θ(‬‭n‬ ‭).‬
‭m‬ ‭m‬
‭L’algorithme‬‭de‬‭multiplication‬‭rapide‬‭va‬‭consister‬‭à‬‭poser‬ ‭x‬ ‭=‬ ‭a‭2
‬ ‬ ‭+‬ ‭b‬ ‭et‬ ‭y‬ ‭=‬‭c‭2
‬ ‬ ‭+‬‭d‬‭avec‬‭m‬‭=‬‭d‭n
‬ /‬‭2‬‭e‬‭puis‬‭à‬
‭2‭m
‬ ‬ ‭m‬
‭calculer‬‭le‬‭produit‬ ‭xy‬ ‭par‬‭la‬‭formule‬‭:‬ ‭xy‬ ‭=‬ ‭ac‬‭2‬ ‭+‬ ‭(‭a
‬ ‬ ‭+‬ ‭b‬‭)(‬‭c‬ ‭+‬ ‭d‭)‬ ‬‭−‬‭ac‬‭−‬‭bd‬‭2‬ ‭+‬‭bd‬‭,‬‭ce‬‭qui‬‭conduit‬‭au‬‭calcul‬
‭log 3‬
‭de‬‭trois produits d’entiers de longueur‬‭m‬‭. Comme précédemment,‬‭le coût va être un Θ‬‭n‬ ‭.‬

‭ emarque.‬ ‭Historiquement,‬ ‭l’algorithme‬ ‭de‬ ‭Karatsuba‬ ‭a‬‭été‬‭le‬‭premier‬‭algorithme‬‭de‬‭multiplication‬‭asympto‬


R
‭tiquement‬‭plus‬‭rapide‬‭que‬‭celui‬‭que‬‭nous‬‭apprenons‬‭tous‬‭à‬‭l’école‬‭primaire.‬‭Il‬‭a‬‭depuis‬‭été‬‭battu‬‭par‬‭d’autres‬
‭algorithmes,‬ ‭celui‬ ‭de‬ ‭Toom-Cook‬ ‭(qui‬ ‭en‬ ‭est‬ ‭un‬ ‭raffinement)‬ ‭et‬ ‭surtout‬ ‭par‬ ‭l’algorithme‬ ‭de‬
‭Schönhage-Strassen,‬ ‭qui‬ ‭utilise‬ ‭la‬ ‭transformation‬ ‭de‬ ‭Fourier‬ ‭rapide.‬ ‭Évidemment,‬ ‭toutes‬ ‭ces‬‭méthodes‬‭ne‬
‭deviennent intéressantes‬‭dans la pratique que pour‬‭multiplier de très grands entiers entre eux.‬

‭3.3 Multiplication de deux matrices‬


I‭ntéressons-nous‬‭pour‬‭finir‬‭au‬‭produit‬‭matriciel‬‭:‬‭si‬ ‭M‬ ‭et‬ ‭N‬ ‭sont‬‭deux‬‭matrices‬‭de‬‭tailles‬ ‭n‬‭×‬‭n‭,‬‬‭leur‬‭addition‬
‭2‬ ‭3‬ ‭2‬
‭nécessite‬‭à‬‭l’évidence‬ ‭n‬ ‭additions‬‭scalaires,‬‭et‬‭leur‬‭produit‬‭par‬‭l’algorithme‬‭naïf,‬‭n‬ ‭multiplications‬‭et‬‭n‬ ‭(‭n ‬ ‬‭−‬‭1)‬
‭additions.‬
‭Peut-on améliorer la complexité du produit en adoptant une méthode « diviser pour régner » ?‬

http://info-llg.f‬

r‬

‭8.8 option informatique‬


‭posons‬‭M‬‭=‬ ‭et‬‭N‬‭=‬ ‭!‬ ‭,‬‭D‭2‬ ‬‭sont des matrices‬
,‭ où‬
‭A‭1‬ ‬‭B‭1‬ ‬‭C‬‭1‬‭D‭1‬ ‬ ‭A‬‭2‬‭B‭2‬ ‬‭C‬‭2‬‭D‭2‬ ‬
‭Supposons‬‭n‬‭= 2‬‭m‬‭et‬‭!‬ ‭A‬‭1‭,‬ ‬‭B‭1‬ ‭,‬ ‭C
‬ ‬‭1‭,‬ ‬‭D‬‭1‭,‬ ‭A
‬ ‬‭2‭,‬ ‭B
‬ ‬‭2‬‭,‬‭C‭2‬ ‬
‭m‬‭×‬‭m‭.‬ Le produit MN est calculé‬ ‭A‭1‬ ‭A
‬ ‬‭2‬‭+ B‬‭1‭C
‬ ‬‭2‬‭A‭1
‬ ‭B
‬ ‬‭2‬‭+ B‬‭1‭D
‬ ‬‭2‬
‭!‬
‭par : MN =‬
‭C‭1‬ ‭A
‬ ‬‭2‬‭+ D‬‭1‭C
‬ ‬‭2‬‭C‭1
‬ ‬‭B‬‭2‬‭+ D‬‭1‭D
‬ ‬‭2‬

‭ t‬ ‭nécessite‬‭a‬‭priori‬‭8‬‭produits‬‭et‬‭4‬‭additions‬‭sur‬‭des‬‭matrices‬ ‭m‬‭×‬‭m‭.‬‬‭Utiliser‬‭ces‬‭formules‬‭conduit‬‭donc‬‭à‬
e
‭2‬ ‭log‬‭8‬ ‭3‬
‭une‬ ‭relation‬ ‭de‬ ‭la‬ ‭forme‬ ‭:‬ ‭c‭n‬ ‬ ‭=‬‭8‭c‬ ‬‭d‭n‬ /‬‭2e‬ ‭+‬ ‭Θ‭(‬ ‬‭n‬ ‭),‬‭ce‬‭qui‬‭conduit‬‭à‬‭un‬‭coût‬‭en‬ ‭Θ‭(‬ ‬‭n‬ ‭)‬‭=‬ ‭Θ‭(‬ ‬‭n‬ ‭).‬‭On‬‭ne‬‭gagne‬
‭donc rien‬‭par rapport à l’algorithme naïf.‬

‭L’algorithme de Strassen utilise les formules suivantes (qu’on laissera le soin au lecteur de vérifier) :‬
‭M‬‭4‬‭= (A‬‭1‬‭+ B‬‭1‭)‬ D‬‭2‬ ‭X = M‬‭1‬‭+ M‬‭2‬‭− M‬‭4‬‭+ M‬‭6‬‭Y‬
‭M‭1‬ ‬‭= (B‬‭1‬‭− D‬‭1‭)‬ (C‬‭2‬‭+ D‬‭2‬‭)‬ ‭M‬ ‭= A‬ ‭(B‬ ‭− D‬ ‭) M‬ ‭=‬ ‭= M‬ ‭+ M‬
‭5‬ ‭1‬ ‭2‬ ‭2‬ ‭6‬ ‭4‬ ‭5‬
‭M‭2‬ ‬‭= (A‬‭1‬‭+ D‬‭1‭)‬ (A‬‭2‬‭+ D‬‭2‭)‬ ‬ D ‭ ‬‭1‭(‬ C‬‭2‬‭− A‬‭2‬‭) M‬‭7‬‭= (C‬‭1‬‭+‬ Z
‭ = M‬‭6‬‭+ M‬‭7‬
‭M‭3‬ ‬‭= (A‬‭1‬‭− C‬‭1‭)‬ (A‬‭2‬‭+ B‬‭2‭)‬ ‬ ‭D‬ ‭)A‬ ‭T = M‬‭2‬‭− M‬‭3‬‭+ M‬‭5‬‭− M‬‭7‬
‭1‬ ‭2‬
‭n’utilisent plus que 7 produits, ce qui‬
‭X Y‬‭Z T‬ ‭donne‬
‭et dans ce cas,‬‭MN‬‭=‬ ‭!‬
‭. On peut observer que ces formules‬
‭log 7‬
‭un coût en Θ(‬‭n‬ ‭) (avec log 7 ≈ 2‬‭,‭8
‬ 07), meilleur‬‭(en théorie en tout cas) que l’algorithme‬

‭naïf.‬‭4. Exercices‬

‭✄‬

‭Exercice 1‬‭Utiliser le principe de la recherche dichotomique‬‭pour rédiger une fonction Caml calculant la‬
‭✂‬ ‭✁‬
‭√‬
‭racine carrée entière d’un entier‬‭n‬‭∈ N, à savoir‬‭b‬ ‭n‭c‬ , avec un coût logarithmique.‬

‭✄‬

‭Exercice 2‬‭Dans cet exercice, on considère un tableau‬‭d’entiers bi-dimensionnel‬‭b‬‭tel que chaque ligne‬‭et‬
‭✂‬ ‭✁‬
‭chaque colonne soit rangée par ordre croissant. Voici un exemple d’un tel tableau, à 4 lignes et 5 colonnes :‬

‭ 14 25 30 69‬
2
‭3 15 28 30 81‬
‭7 15 32 43 100‬
‭20 28 36 58 101‬

‭ e but de l’exercice est de rechercher efficacement un élément‬‭v‬‭dans un tel‬


L
‭k‬
‭tableau. Pour simplifier, on supposera que ce tableau comporte‬‭n‬‭= 2‬ ‭lignes et‬
‭colonnes.‬

‭n‬ ‭n‬ ‭n‬ ‭+ 1‬‭,‭n‬ ‬ ‭+ 1‬


‭a)‬‭On distingue les deux valeurs‬‭x‬‭=‬‭b‬ ‭2‬‭,‬ ‭2‬‭et‬‭y‬‭=‬‭b‬ ‭2‬ ‭2‬ ‭. Montrer que si‬‭v > x‬‭, on peut‬

‭ liminer une‬‭partie (à préciser) du tableau pour poursuivre‬‭la recherche.‬


é
‭Préciser ce qu’il est possible de faire lorsque‬‭v‬‭< y‬‭.‬
‭b)‬‭En déduire une méthode « diviser pour régner »‬‭pour résoudre ce problème, et préciser le coût dans le‬
‭pire‬‭des cas, en nombre de comparaisons, de cette‬‭méthode.‬

‭✄‬
‭k‬
‭Exercice 3‬‭On considère un échiquier carré de côté‬‭n‬‭= 2‬ ‭, que l’on souhaite paver avec les quatre motifs‬

‭✂‬ ‭✁‬
‭ci-dessous :‬

‭ achant que 4‬‭k‬‭≡‬‭1 (‬‭mod‬‭3), ce n’est bien évidemment‬‭pas possible, mais nous allons montrer que si on‬
S
‭isole‬‭une case de coordonnées (‬‭x,y‬‭) choisie arbitrairement,‬‭le reste de l’échiquier peut alors être recouvert :‬
‭Diviser pour régner 8.9‬

‭ ontrer en raisonnant par récurrence sur‬‭k‬‭qu’un tel‬‭recouvrement est toujours possible, en décrivant un‬
M
‭algorithme « diviser pour régner » résolvant ce problème.‬
‭✄‬

‭Exercice 4‬‭Étant donnée une suite finie d’entiers‬‭x‬‭= (‬‭x‭1‬ ‭,‬ ..., x‬‭n‭)‬ , on appelle‬‭inversion‬‭de‬‭x‬‭tout couple‬‭(‭i‬, j‬‭) tel‬
‭✂‬ ‭✁‬
‭que‬‭i < j‬‭et‬‭x‭i‬‬‭> x‬‭j‬‭. Par exemple, (2‬‭,‭3
‬ ‭,‬‭1
‬ ‬‭,‬‭5‭,‬‬‭4) possède‬‭3 inversions : les couples (1‬‭,‭3
‬ ), (2‬‭,‭3
‬ ), (4‬‭,‭5
‬ ). On‬
‭s’intéresse au calcul du nombre d’inversions de‬‭x‬‭.‬
‭2‬
‭ )‬‭Rédiger en Caml l’algorithme naïf, et montrer que‬‭son coût est un‬‭Θ‭(‬ ‬‭n‬ ‭). On représentera les suites‬‭finies‬
a
‭d’entiers par le type‬‭int vect‬‭.‬
‭b)‬‭Adopter une méthode « diviser pour régner » pour‬‭faire mieux (indication : adapter l’algorithme de tri‬
‭fusion).‬

‭✄‬

‭Exercice 5 Une matrice de Tœplitz est une matrice (‬‭a‬‭i,j‬‭) ∈ M‬‭n‭(‬ K) telle que‬‭a‭i‬,j‬‭=‬‭a‭i‬‬‭−1‬‭,j‬‭−1‬‭pour 2 6‬‭i, j‬‭6‬‭n‭.‬‬
‭✂‬
‭✁‬
‭a)‬‭Trouver un moyen d’additionner deux matrices de‬‭Tœplitz en Θ(‬‭n‬‭).‬
‭b)‬‭Appliquer une méthode « diviser pour régner » pour‬‭calculer le produit d’une matrice de Tœplitz‬‭n‬‭×‬‭n‬‭par‬
‭k‬
‭ n vecteur de longueur‬‭n‬‭(en supposant pour simplifier‬‭que‬‭n‬‭= 2‬ ‭).‬
u
‭Quel est la complexité de votre algorithme ?‬

‭✄‬

‭Exercice 6‬‭On pourrait imaginer remplacer, dans l’algorithme‬‭d’exponentiation rapide, la base 2 par la base‬
‭✂‬ ‭✁‬
‭3 et exploiter les relations‬ ‭‬ ‭3‬ ‭k‬
‭‭(‬ ‭x‬ ‬ ‭)‬ ‭si‬‭n‬‭= 3‬‭k‬‭;‬
‭3‬ ‭k‬ ‭2‬ ‭3‬ ‭k‬
‭x‬‭(‭x‬ ‬ ‭)‬ ‭si‬‭n‬‭= 3‬‭k‬‭+ 1 ;‬‭x‬ ‭(‭x‬ ‬ ‭)‬ ‭si‬‭n‬‭=‬
‭n‬ ‭3‬‭k‬‭+ 2.‬
‭suivantes :‬‭x‬ ‭=‬
‭Déterminer le coût d’un tel algorithme, et le comparer au coût de l’algorithme binaire.‬

http://info-llg.fr‬

Vous aimerez peut-être aussi