Proximity Closest pair, divide-and-conquer

1
ProximityClosest pair, divide-and-conquer
Closest pair CLOSEST PAIR INSTANCE Set S p1,
p2, ..., pN of N points in the plane. QUESTION
Determine the two points of S whose
mutual distance is smallest. Weve seen a proof
that CLOSEST PAIR has a lower bound for time ?
?(N log N). We seek an algorithm with upper bound
? O(N log N). If found, these together imply that
CLOSEST PAIR ? ?(N log N). Two algorithm
paradigms come to mind for O(N log
N) 1. Sorting 2. Divide-and-conquer To use
sorting, a total ordering of the points is
needed, but none seem useful. For example,
projecting the points of S onto the y axis give a
total ordering on y coordinate but
destroys useful information points p1 and p2
are closest in Euclidean distance but farthest in
y distance.
2
ProximityClosest pair, divide-and-conquer
Divide-and-conquer, concept Using the
divide-and-conquer paradigm, time in O(N log N)
can be achieved by 1. Dividing the problem into
two equal-sized subproblems 2. Solving those
subproblems recursively 3. Merging the subproblem
solutions into an overall solution in linear
O(N) time. Unfortunately, it is not immediately
obvious how to perform the merge in linear
time. Suppose the problem has been solved for
subproblem sets S1 and S2, where S1 ? S2 S, S1
? S2 ?, S1 ? S2 ? N/2 giving a closest
pair of points for S1 and another for S2. How
can the closest pair for S be found? It may
consist of one point from S1 and one from
S2. Testing all possible pairs of points from S1
and S2 requires time in O(N/2) O(N/2) ?
O(N2), which is unsatisfactory.
S1
S2
3
ProximityClosest pair, divide-and-conquer
Divide-and-conquer for d 1, 1 We consider a
divide-and-conquer algorithm for CLOSEST PAIR in
1 dimension (d 1). Partition S, a set of
points on a line, into two sets S1 and S2 at some
point m such that for every point p ? S1 and q ?
S2, p lt q. Solving CLOSEST PAIR recursively on S1
and S2 separately produces p1, p2, the closest
pair in S1, and q1, q2, the closest pair in
S2. Let ? be the smallest distance found so
far ? min(p2 - p1, q2 - q1) The closest
pair in S is either p1, p2 or q1, q2 or some
p3, q3 with p3 ? S1 and q3 ? S2.
4
ProximityClosest pair, divide-and-conquer
Divide-and-conquer for d 1, 2 To check for such
a point p3, q3, is it necessary to test every
possible pair of points in S1 and S2? Note that
if p3, q3 is to be closer than ? (i.e., q3 -
p3 lt ?), then both p3 and q3 must be within ? of
m. How many points of S1 can lie within ? of
m, i.e., within the interval (m - ?, m? Because
? is the distance between the closest pair in
either S1 or S2, a semi-closed interval of length
? can contain at most 1 point. For the same
reason, there can be at most 1 point of S2 within
? of m, i.e., in the interval m, m ?). So, the
number of distance computations needed to
check for a closest pair p3, q3 with p3 ? S1
and q3 ? S2 is 1, not O(N2). Finding any points
in the intervals (m - ?, m and m, m ?) to do
the computation can take at most O(N)
time, giving a linear merge step. Thus a
divide-and-conquer algorithm can solve
1-dimensional CLOSEST PAIR in O(N log N) time.
S1
S2
?
?
p1
p2
p3
q3
q1
q2
m
5
ProximityClosest pair, divide-and-conquer
Divide-and-conquer for d 1, 3 procedure
CPAIR1(S) Input X1N, N points of S in one
dimension. Output ?, the distance between the
two closest points. 1 begin 2 if (S 2)
then 3 ? X2 - X1 4 else if (S 1)
then 5 ? ? 6 else 7 begin 8 Construc
t(S1, S2) / S1 p p ? m, S2 p p gt m
/ 9 ?1 CPAIR1(S1) 10 ?2
CPAIR1(S2) 11 p max(S1) 12 q
min(S2) 13 ? min(?1, ?2, q -
p) 14 end 15 endif 16 return
? 17 end Caveat Note that p ( p3) and q ( q3)
are found not by looking within intervals (m - ?,
m and m, m ?), but by identifying the two
points closest to m. This works for d 1 but
not for d ? 2. For that reason the idea of p3 and
q3 within ? of m was introduced.
6
ProximityClosest pair, divide-and-conquer
Generalizing to d 2 Partition two dimensional
set S into subsets S1 and S2 such that every
point of S1 lies to the left of every point of
S2. To do so, cut S by vertical line l at the
median x coordinate of S. Solve the problem
recursively on S1 and S2. Let p1, p2 be the
closest pair in S1 and q1, q2 in S2. ?1
distance(p1,p2) and ?2 distance(q1,q2) are the
minimum separations in S1 and S2 respectively. ?
min(?1, ?2)
S1
l
S2
p1
?1
p2
q1
?2
q2
7
ProximityClosest pair, divide-and-conquer
Where is the closest pair? To perform the merge
it must be determined if there is a pair of
points p, q such that p ? S1 and q ? S2 and
distance(p, q) lt ?. If such a pair exists, then p
and q must both be within ? of l. Let P1 and P2
be vertical strips (regions) of the plane of
width ? on either side of l. If p, q exists, p
must be within P1 and q within P2. For d 1,
there was at most one candidate point for p and
one for q. For d 2, every point in S1 and S2
may be a candidate, as long as each is within ?
of l. This seems to imply that O(N/2) ? O(N/2) ?
O(N2) distance computations may be needed
unsatisfactory.
P1
l
P2
?
?
p1
q1
S2
?1
S1
p2
?2
q2
8
ProximityClosest pair, divide-and-conquer
Closing in on the closest pair But is it really
necessary for some p ? S1 and within P1, to
determine the distance to every point q ? S2 and
within P2? No. We really only need to do so for
those points that are within ? of p. Thus we can
bound the portion of P2 to consider by that
distance. The points to consider for a point p
must lie within the ? ? 2? rectangle R.
P1
l
P2
?
?
?
S2
S1
p
?
R
9
ProximityClosest pair, divide-and-conquer
Distance computations required How many points
can there be in rectangle R? Recall that no two
points in P2 are closer than ?. Because rectangle
R has size ? ? 2?, there can be at most 6 points
within it any more and they would be closer than
?, a contradiction. This means that for each of
the O(N/2) points p ? S1 within P1, only 6 points
must be checked, not O(N/2) for each, so 6 ?
O(N/2) O(3N) ? O(N) distance comparisons are
needed in the merge step, not O(N2). ? An O(N log
N) algorithm for CLOSEST PAIR is possible.
P1
l
P2
?
?
?
S2
S1
p
?
R
10
ProximityClosest pair, divide-and-conquer
Which points much be checked? Though an O(N log
N) algorithm is possible, we do not have it
yet. Though we know that for a point p only 6
points within P2 must be checked, we do not yet
know which six. Project p and all the points of
S2 within P2 onto l. Only the points within ? of
p in that projection (y coordinate) need be
considered as seen, there will be ? 6. By
sorting the points of S in order on y
coordinate, the nearest neighbor candidates for a
point p can be found by scanning the sorted list.
P1
l
P2
?
?
?
S2
S1
p
?
R
11
ProximityClosest pair, divide-and-conquer
Closest pair algorithm Algorithm from Preparata,
p. 198 1. Partition S into two subsets, S1 and
S2, about the vertical median line l. 2. Find
the closest pair separations ?1 and ?2
recursively. 3. ? min(?1, ?2) 4. Let P1 be
the set of points of S1 that are within ? of
the dividing line l and let P2 be the
corresponding subset of S2. Project P1 and P2
onto l and sort by y coordinate. Let P1 and
P2 be the two sorted sequences,
respectively. 5. The merge may be carried out
by scanning P1 and for each point in P1
inspecting the points of P2 within distance ?.
While a pointer advances on P1, the pointer
of P2 may oscillate within an interval of
width 2?. Let ?1 be the smallest distance of
any pair thus examined. 6. ?S min(?,?1) Step
4 appears to put an O(N log N) sort into each
merge. It seems to have been written that way for
clarity only. To achieve an O(N) merge, all the
points of S are sorted at the start of the
algorithm (presorting). The sorted sequences
P1 and P2 are obtained in O(N) time from the
presorted list.
12
ProximityClosest pair, divide-and-conquer
Merge process algorithm Preparata p. 199 says
when executing Step 4, extract the points from
the list in sorted order in only O(N) time. One
way to assemble P1, for example, follows. Let Y
be the presorted points of S, i.e., an array of
size N storing the points of S in order by
ascending y coordinate each entry has three
fields x, y, and active. Let P1 be an array of
size N with two fields index and y. 1 for i
1 to N / Initialize P1. / 2 P1i.index
0 3 P1i.y 0 4 endfor 5 for every point
pi ? S 6 Yi.active FALSE 7 endfor 8 for
every point pi ? S1 / Mark the points of P1 in
Y. / 9 Yi.active TRUE 10 endfor 11 j
1 12 for i 1 to N / Retrieve the points in
sorted order. / 13 if Yi.active
TRUE 14 P1j.index i / Points to Y for
coordinate retrieval. / 15 j j
1 16 endif 17 endfor
13
ProximityClosest pair, divide-and-conquer
Analysis Let T(N) be the running time of the
algorithm on N points. The steps of CPAIR2
require 1. O(N) 2. 2T(N/2) 3. O(1) 4. O(N) 5
. O(N) 6. O(1) Thus, T(N) 2T(N/2) O(N) ?
O(N log N). The presort of S on y coordinate also
requires O(N log N) time. Overall time for the
CPAIR2 algorithm to solve the CLOSEST PAIR
problem for d 2 is O(N log N). Because CLOSEST
PAIR problem for d 2 has a lower bound in ?(N
log N) for any algorithm, this complexity is
optimal, i.e., ?(N log N).
14
ProximityClosest pair, divide-and-conquer
Closest pair for d gt 2 Preparata p. 199-204
discusses solving CLOSEST PAIR using
a divide-and-conquer algorithm for d gt 3. The
approach depends on the notion of sparsity, a
measure of how many points can be in a
d-dimensional hypercube with sides that measure
2. We made use of sparsity in the d 1 and d 2
case. The result is that the closest pair of
points in a set of N points in Ed can be found in
?(N log N) time.