Corrigé du DM 1 : recherche des plus proches voisins
Judicaël Courant 2018-W14-3 (3 avril)
1 Préliminaires
Question 1
let rec minimise l f =match l with
| [ ] → failwith "Liste vide"
| [x] → x
| x ::y ::r → letz = minimise l f in if f x < f z
thenx elsez
Question 2
let rec filtre l p =match l with
| [ ] → [ ]
| x ::r → if p x thenx :: filtre l p elsefiltre l p
Question 3
let rec nth l n =match l with
| [ ] → failwith "Liste vide"
| x ::r → if n = 0then x elsenth r (n−1)
Question 4
let rec first l n = matchl, n with
| , 0 | [ ], → [ ]
| x ::r, → x :: first r (n−1)
Une récurrence immédiate permet de montrer que pour tout entier i et toute liste l, l’appel (first l i) conduit au plus àiappels récursifs (en plus de l’appel initial).
Or lors de chacun des appels, on effectue au plus une opération de filtrage, une soustraction et un cons, qui sont des opérations de temps constant.
Le temps d’exécution de(first l i) est donc un O(i), indépendamment de la longueur de l.
2 Méthode naïve
typepoint =float ×float
Question 5
On peut représenter les vecteurs du plan par des couples de points :
typevecteur = float ×float
On définit alors naturellement la fonction calculant la norme euclidienne :
norme : vecteur → float
letnorme (x, y) = sqrt (x ∗.x +.y ∗.y) vect : point → point → vecteur vect P Qretourne le vecteur−−→
P Q
letvect (x, y) (x0, y0) = (y0 −.y, x0 −.x) On peut alors définir la fonction dist : point →
point → float demandée : letdist p q = norme (vect p q)
Question 6
letplus proche p l = minimise l (funq → dist p q)
Question 7
Notonsf la fonctionfunq → dist p qet remarquons que f s’exécute sur tout point p en temps constant.
L’exécution de plus proche p l conduit à exécuter minimise l f, ce qui conduit au total à O(|l|) appels deminimise, où|l|désigne la taille del. Or, à chaque appel, la fonctionminimise n’effectue que des opéra- tions en temps constant, en dehors de l’éventuel appel récursif. Son temps d’exécution est donc dominé par son nombre d’appels.
L’exécution de plus proche p l demande donc un tempsO(n), oùn est la longueur del.
Question 8
let rec liste plus proches l =match l with
| [ ] → [ ]
| [p] → [ ]
| p ::r →
(p, plus proche p r) :: liste plus proches r
Question 9
Considérons l’exécution de liste plus proche l dans le cas le pire pour une liste l de longueur n. Pour n ≥ 1, cette exécution conduit à n appels de liste plus proche (appel initial inclus). À chaque ap- pel, on exécute des opérations de temps constant (fil- trage, cons), plus un éventuel appel àplus prochesur une sous-liste de l, ce qui demande donc un temps O(n), plus un éventuel appel récursif.
Le temps d’exécution deliste plus proche l est donc O(n2).
Question 10
letplus proches voisins naif l = letl1 = liste plus proches l in minimise l1 (fun (p, q) → dist p q)
Question 11
Pour une liste l de longueur n, l’appel à liste plus proches l s’exécute en temps O(n2) et construit une liste l1 de longueur n−1. Le calcule de minimise l1 (fun (p, q) → dist p q) demande alors un tempsO(n−1), le temps de calcul d’un appel àdist ne dépendant pas de ses arguments.
Le temps total de calcul deliste plus proches l est doncO(n2) +O(n−1) =O(n2).
NB : Il s’agit bien d’une somme et non d’un pro- duit.
3 Diviser pour régner
3.1 Modélisation du problème
typenuage = {
par x puis y : point list; par y : point list;
}
Question 12
Nous définissons une fonction lexico : point → point → int telle que lexico p q retourne un entier strictement négatif si p est strictement inférieur à q dans l’ordre lexicographique, 0 s’ils sont égaux et un entier strictement positif sinon.
letlexico (x1, x2) (y1, y2) = match compare x1 x2 with
| 0 → compare y1 y2
| c → c
Nous pouvons maintenant écrire la fonction deman- dée :
letcree nuage l =
let parx = List.sort lexico l in let pary =
List.sort
(fun(x1, x2) (y1, y2) → compare x2 y2) l
in
{ par x puis y = parx; par y = pary } Soit l une liste de longueur N. La fonction List.sort utilise une variante du tri fusion et s’exécute donc sur l en temps O(NlogN) lorsque les fonctions de comparaison utilisées s’exécutent en temps constant.
Le calcul de parx et de pary dans l’exécu- tion de cree nuage l s’effectue donc en temps O(NlogN).
Question 13
Nous proposons le code suivant pourfiltre nuage : letfiltre nuage n f =
let parx = filtre n.par x puis y f in let pary = filtre n.par y f in
{ par x puis y = parx; par y = pary } Il reste à montrer d’une part sa correction (le fait qu’il retourne un nuage vérifiant les propriétés demandées) et d’autre part que sa complexité est linéaire en la taille du nuage si la fonction f s’exécute en temps constant.
Notons n un nuage de taille N et f une fonction s’exécutant en temps constant. Alorsn.par x puis y est une liste de longueur N, donc le calcul de parx dans l’exécution de filtre nuage n f s’effectue en temps O(N) comme on l’a vu précédemment. De même, celui depary s’effectue en temps O(N).
Donc, lorsque f s’exécute en temps constant et que n est un nuage de taille N, le calcul de filtre nuage n f s’effectue en tempsO(N).
De plus, puisque n est un nuage, n.par x puis y etn.par y contiennent le même ensemble de points.
Donc les listesparx etpary calculées par l’exécution defiltre nuage n f contiennent également les mêmes ensembles de points.
Il est clair que si une listel est triée pour un certain ordre, alors pour toute fonction f, filtre l f est éga- lement triée pour ce même ordre. Donc la liste parx etpary est triée par ordre lexicographique et la liste pary est triée par ordonnées croissantes.
Le nuage construit par filtre nuage n f res- pecte donc les trois conditions requises.
3.2 Découpage en sous-problèmes Question 14
Considérons un nuage nde taille k, dont la liste des points trié par ordre lexicographique estP0, . . . ,Pk−1. Alors, en posant i= bk/2c, la liste P0, . . . , Pi−1 est de longueur i. Cette liste est exactement la liste des points précédant strictement Pi dans l’ordre lexico- graphique (les points étant tous distincts). D’où le code suivant :
letcoupe n =
letk = List.length n.par x puis y in leti = k / 2 in
letp = nth n.par x puis y i in letng =
filtre nuage n (funq → lexico q p < 0)in letnd =
filtre nuage n (funq → lexico q p ≥ 0)in ng, p, nd
L’exécution decoupe n, oùnest un nuage de tailleN, demande le calcul de la longueur den.par x puis y, ce qui se fait en tempsO(N), le calcul d’une division euclidienne qui se fait en temps constant, deux appli- cations defiltre nuage. Les fonctions données en ar- gument àfiltre nuage s’exécutent en temps constant et les listes données en arguments sont de tailles bN/2c = O(N) et N − bN/2c = dN/2e = O(k) = O(N).
3.3 Combinaison des solutions des sous-problèmes
Question 15
On a Eg ⊂ E, donc Eg2 ⊂ E2, donc
d(x, y)
(x, y)∈Eg2 ⊂
d(x, y)
(x, y)∈E2 . Le minimum δg du premier ensemble est donc supé- rieur ou égal au minimum δ0 du second. De même δd≥δ0.
Donc δ0 ≤min(δg, δd) =δ . Question 16
DESSIN Question 17
Soit (M, M0) un couple de plus proches voisins.
Puisque δ0 < δ, on ne peut avoir (M, M0) ∈ Eg ni (M, M0)∈Ed. Donc l’un des points appartient àEg, l’autre àEd. Sans perte de généralité, on peut suppo- serM ∈EgetM0 ∈Ed. Notons(x, y)les coordonnées de M et(x0, y0)celles de M0.
On a x ≤ xP ≤ x0. En particulier, 0 ≤x0−xP ≤ x0−x et0≤xP −x≤x0−x et0≤x0−x.
Or d(M, M0) = p
(x0−x)2+ (y0−y)2 ≥ |x0−x|, d’où0≤x0−x≤δ0.
Donc0≤x0−xP ≤δ0 et0≤xP −x≤δ0. DoncM ∈VB etM0∈VB.
Question 18 DESSIN
Supposons par l’absurde qu’au moins cinq points de Eg∩VB ont des ordonnées appartenant à [yi, yj]. On dispose alors de cinq pointsM1, . . . ,M5 appartenant au rectangle[xP −δ0, xP +δ0]×[yi, yj].
Ce rectangle est la réunion des quatre rectangles R1,R2,R3 etR4 définis par
R1 = [xP −δ0, xP −δ0/2]×[yi,(yi+yj)/2]
R2 = [xP −δ0/2, xP]×[yi,(yi+yj)/2]
R3 = [xP −δ0, xP −δ0/2]×[(yi+yj)/2, yj] R4 = [xP −δ0/2, xP]×[(yi+yj)/2, yj]
Chacun des pointsM1, . . . , M5 appartient au moins à l’un de ces rectangles, donc d’après le principe de Dirichlet, au moins deux points distincts Ma et Mb appartiennent au même rectangle Ri. Or le diamètre de chacun des rectangles vaut
d= q
δ02/4 + (yj−yi)2/4≤δ0/√ 2< δ0 Doncd(Ma, Mb)≤d < δ0.
C’est absurde, donc au plus quatre points deEg∩ VB ont des ordonnées appartenant à[yi, yj].
De la même façon, au plus quatre points deEd∩VB ont des ordonnées appartenant à[yi, yj].
Question 19
D’après ce qui précède, au plus8point deVB ont des ordonnées comprises entreyi etyj.
Par l’absurde, supposons j > i + 7, c’est-à-dire j ≥ i + 8. Alors comme la liste (x0, y0), . . . , (xk0−1, yk0−1) est triée par ordonnées croissantes, les points Mi, . . . , Mj constituent au moins 9 points de VB d’ordonnées appartenant à [yi, yj].
C’est absurde, donc on a j≤i+ 7.
Question 20
Cette fonction est très similaire à liste plus proches écrite plus haut. La différence est qu’au lieu d’appeler plus prochesur la queue de la liste, on l’appelle sur la sous-liste constituée des7premiers éléments de cette queue.
let rec liste plus proches 7 l =match l with
| [ ] | [ ] → [ ]
| p ::r → letpp7 = plus proche p (first r 7)in (p, pp7) :: liste plus proches 7 r L’exécution de liste plus proches 7 l pour une liste de longueurn(avecn≥1) conduit au total ànappels à liste plus proches 7 (appel initial inclus), sur des listes toutes de longueur au plusn.
À chacun de ces appels, on effectue, en dehors de l’éventuel appel récursif, uniquement des opérations en temps constant. En effet, le calcul defirst r 7sur une liste r quelconque se fait en temps constant, le temps de calcul defirst étant linéaire en son deuxième argument. De plus ce calcul retourne une liste de lon- gueur constante, donc l’appel deplus proche s’effec- tue également en temps constant. Enfin, filtrage et cons s’exécutent également en temps constant.
Le temps de calcul de liste plus proches 7 l est donc dominé par le nombre d’appel, lui-même linéaire en|l|.
Le temps de calcul de liste plus proches 7 l sur une liste de longueurn est doncO(n).
Question 21
let rec plus proches 7 l =
letlpp7 = liste plus proches 7 l in minimise lpp7 (fun(p, q) → dist p q)
On a vu que pour une liste l de longueur n, liste plus proche 7 l prenait un temps O(n). De plus, elle retourne une liste l0 de longueur n−1. Or le temps de calcul deminimise f r est enO(N)pour toute liste r de longueur N et toute fonction f tra- vaillant en temps constant.
Donc, pour toute listelde longueurn: le temps d’exécution deplus proche 7 l estO(n).
3.4 Résolution récursive
Question 22
On peut rechercher les plus proches voisins dans un nuagen de taillek≥2 comme suit :
— Si k <4, on utilise l’algorithme naïf.
— Sinon, on coupe ce nuage en deux, comme pro- grammé précedemment : on obtient des sous- nuagesng etndrespectivement de taillesbk/2c etdk/2eainsi qu’un pointP tel queng contient tous les points de n strictement inférieurs à P dans l’ordre lexicographique et nd tous les autres points.
— Chacun de ces sous-nuages comporte au moins deux points. On peut alors appliquer récursive- ment l’algorithme sur ces deux sous-nuages. On obtient alors des couples de plus proches voisins (Mg, Mg0) et(Md, Md0) respectivement pourng
etnd.
— On calcule δ = min(d(Mg, Mg0), d(Md, Md0)).
— On calcule la listeLdes points denappartenant àVB(i.e. d’abscisses dans[xP−δ, xP+δ]), triée par ordre croissant d’ordonnées.
— Si cette liste possède au moins deux éléments, on calcule le couple(M, M0) des points les plus proches sous la contrainte que leur différence d’indice dans L est au plus 7 et on retourne, parmi les trois couples (M, M0), (Mg, Mg0) et (Md, Md0)celui dont les deux points sont les plus proches.
— Sinon, on retourne parmi les deux couples (Mg, Mg0)et(Md, Md0)celui dont les deux points sont les plus proches.
Chaque appel récursif se fait sur des nuages de tailles strictement plus petites car bk/2c < k pour toutk≥2. Donc l’algorithme termine.
Par ailleurs, il est clair que l’algorithme est correct pour k = 2 et pour k= 3. En outre, si l’on suppose par l’absurde qu’il existe des nuages de taille supé- rieure ou égale à2pour lesquels il donne une réponse incorrecte, considérons un tel nuage nde taillek mi- nimale.
Alors, k ≥4 puisque l’algorithme est correct pour k= 2etk= 3. Donc l’algorithme est appellé récursi- vement sur les sous-nuagesng etnd, de taille stricte- ment inférieure à k et pour lesquels on obtient donc le bon résultat.
Alors, en notantδ0 la distance minimale entre deux points de n:
— ou bienδ0 < δet dans ce cas il existe deux points M et M0 dans L, de distance δ, de différence d’indices au plus7et ce couple est bien le couple retourné par l’algorithme.
— ou bien δ0 = δ et dans ce cas, les couples de
points de L sont tous de distances supérieures ou égales à δ entre eux et l’algorithme retour- nera bien un couple de points à distanceδ.
Donc dans tous les cas, le résultat correct sera re- tourné, ce qui est absurde.
Donc l’algorithme est correct.
Question 23
lettaille nuage n = List.length n.par y let rec pp voisins rec n =
letk = taille nuage n in if k ≤ 3
thenplus proches voisins naif n.par y else
let ng, (xp, yp), nd = coupe n in let mg, mg0 = pp voisins rec ng in let md, md0 = pp voisins rec nd in let dg = dist mg mg0 in
let dd = dist md md0 in let delta = min dg dd in let f (x, ) =
x ≥ xp −.delta ∧ x ≤ xp +.delta in let vb = filtre n.par y f in
(∗points potentiellement les plus proches :∗) let c =match vb with
| [ ] | [ ] → [(mg, mg0); (md, md0)]
| → letm, m0 = plus proches 7 vb in [(m, m0); (mg, mg0); (md, md0)]
in
minimise c (fun (p, q) → dist p q)
Question 24
Pour k au voisinage de +∞, le temps de calcul de pour un nuage de taillen de taillek0 ≤kest ou bien majoré par une constante si ce nuage est de taille au plus3, ou bien le temps cumulé des exécutions de
— coupe n, qui est enO(k0).
— pp voisins rec ng, enT(bk0/2c)
— pp voisins rec nd, enT(dk0/2e)
— dist mg mg0,dist md md0,min dg dd en O(1),
— filtre f n.par y en temps O(k0),
— éventuellement plus proches 7 vb, en temps O(k00) avec k00≤k.
— minimise c (fun p q → dist p q) en temps constant,cétant de longueur au plus 3.
Pour tout x≤y, on aT(x)≤T(y) d’après la défini- tion deT, donc T(bk0/2c)≤T(dk0/2e)≤T(dk/2e).
On en déduit :
T(k)≤k→+∞2T(dk/2e) +O(k) Question 25
On a alors
uk+1−2uk=T(2k+1)−2T(2k)
≤2T(2k) +O(2k+1) + 2T(2k)
≤O(2k)
Question 26 On en déduit
uk+12−k−1−uk/2−k≤O(1) Autrement dit, la suite uk+12−k−1−uk2−k
est ma- jorée par une constanteM D’où, par somme télesco- pique :
uk/2k−u0/20 ≤M ×k=O(k)
On en déduit0≤uk≤O(k·2k), donc uk =O(2k·k)
Question 27
On en déduit successivement : T(n)≤T(2dlog2ne)
≤O(2dlog2ne· dlog2ne) leqO(n·log2n)
Et comme0≤T(n), on en déduit T(n) =O(nlogn)
Question 28 letpp voisins l =
let n = cree nuage l in pp voisins rec n
Question 29
On sait que la complexité de l’appel cree nuage l est O(nlogn) pour une liste l de taille n. Le nuage alors créé est de taille n également et la complexité depp voisins rec appliqué à ce nuage estO(nlogn).
On en déduit que la complexité de l’exécution depp voisins l estO(nlogn)oùnest la taille de l.
Question 30
Il suffit de trier la liste pour en retirer les doublons avant d’appliquerpp voisins.
retire doublons : α list → α list retire les dou- blons d’une liste déjà triée.
let rec retire doublons l =matchl with
| [ ] | [ ] → [ ]
| x ::y ::r →
if x = y thenretire doublons (y ::r) elsex :: retire doublons(y ::r) letpp voisins ext l =
letl0 = retire doublons (List.sort lexico l) in pp voisins l0
Pour une listel de longueurn, le tri de la listel se fait enO(nlogn). La fonctionretire doublonstravaille en temps linéaire en la taille de liste qui lui est passée en argument, donc ici enO(n). Elle retourne une listel0 de taille inférieure ou égale à n, donc l’exécution de pp voisins l0 se fait enO(nlogn).
Le temps total d’exécution depp voisins ext l est donc un O(nlogn), oùnest la taille de l.
