Closest pair of points problem

The closest pair of points problem or closest pair problem is a

problem of computational geometry: given points in metric space,
find a pair of points with the smallest distance between them. The
closest pair problem for points in the Euclidean plane[1] was among
the first geometric problems that were treated at the origins of the
systematic study of the computational complexity of geometric
algorithms.

Time bounds
Randomized algorithms that solve the problem in linear time are
known, in Euclidean spaces whose dimension is treated as a Closest pair of points shown in red
constant for the purposes of asymptotic analysis.[2][3][4] This is
significantly faster than the time (expressed here in big O
notation) that would be obtained by a naive algorithm of finding distances between all pairs of points and
selecting the smallest.

It is also possible to solve the problem without randomization, in random-access machine models of
computation with unlimited memory that allow the use of the floor function, in near-linear
time.[5] In even more restricted models of computation, such as the algebraic decision tree, the problem can
be solved in the somewhat slower time bound,[6] and this is optimal for this model, by a
reduction from the element uniqueness problem. Both sweep line algorithms and divide-and-conquer
algorithms with this slower time bound are commonly taught as examples of these algorithm design
techniques.[7][8]

Linear-time randomized algorithms

A linear expected time randomized algorithm of Rabin (1976), modified slightly by Richard Lipton to make
its analysis easier, proceeds as follows, on an input set consisting of points in a -dimensional
Euclidean space:

1. Select pairs of points uniformly at random, with replacement, and let be the minimum
distance of the selected pairs.
2. Round the input points to a square grid of points whose size (the separation between
adjacent grid points) is , and use a hash table to collect together pairs of input points that
round to the same grid point.
3. For each input point, compute the distance to all other inputs that either round to the same
grid point or to another grid point within the Moore neighborhood of surrounding grid
points.
4. Return the smallest of the distances computed throughout this process.

The algorithm will always correctly determine the closest pair, because it maps any pair closer than distance
to the same grid point or to adjacent grid points. The uniform sampling of pairs in the first step of the
algorithm (compared to a different method of Rabin for sampling a similar number of pairs) simplifies the
proof that the expected number of distances computed by the algorithm is linear.[4]

Instead, a different algorithm Khuller & Matias (1995) goes through two phases: a random iterated filtering
process that approximates the closest distance to within an approximation ratio of , together with a
finishing step that turns this approximate distance into the exact closest distance. The filtering process repeat
the following steps, until becomes empty:

1. Choose a point uniformly at random from .

2. Compute the distances from to all the other points of and let be the minimum such
distance.
3. Round the input points to a square grid of size , and delete from all points whose
Moore neighborhood has no other points.

The approximate distance found by this filtering process is the final value of , computed in the step before
becomes empty. Each step removes all points whose closest neighbor is at distance or greater, at least
half of the points in expectation, from which it follows that the total expected time for filtering is linear.
Once an approximate value of is known, it can be used for the final steps of Rabin's algorithm; in these
steps each grid point has a constant number of inputs rounded to it, so again the time is linear.[3]

Dynamic closest-pair problem

The dynamic version for the closest-pair problem is stated as follows:

Given a dynamic set of objects, find algorithms and data structures for efficient recalculation
of the closest pair of objects each time the objects are inserted or deleted.

If the bounding box for all points is known in advance and the constant-time floor function is available,
then the expected -space data structure was suggested that supports expected-time
insertions and deletions and constant query time. When modified for the algebraic decision tree model,
insertions and deletions would require expected time.[9] The complexity of the dynamic closest
pair algorithm cited above is exponential in the dimension , and therefore such an algorithm becomes less
suitable for high-dimensional problems.

An algorithm for the dynamic closest-pair problem in dimensional space was developed by Sergey
Bespamyatnikh in 1998.[10] Points can be inserted and deleted in time per point (in the worst
case).

See also
GIS
Nearest neighbor search

Notes
1. Shamos, Michael Ian; Hoey, Dan (1975). "Closest-point problems". 16th Annual Symposium
on Foundations of Computer Science, Berkeley, California, USA, October 13-15, 1975. IEEE
Computer Society. pp. 151–162. doi:10.1109/SFCS.1975.8 (https://doi.org/10.1109%2FSFC
S.1975.8).
 2. Rabin, M. (1976). "Probabilistic algorithms". Algorithms and Complexity: Recent Results and
New Directions. Academic Press. pp. 21–39. As cited by Khuller & Matias (1995).
3. Khuller, Samir; Matias, Yossi (1995). "A simple randomized sieve algorithm for the closest-
pair problem". Information and Computation. 118 (1): 34–37. doi:10.1006/inco.1995.1049 (htt
ps://doi.org/10.1006%2Finco.1995.1049). MR 1329236 (https://mathscinet.ams.org/mathscin
et-getitem?mr=1329236). S2CID 206566076 (https://api.semanticscholar.org/CorpusID:2065
66076).
4. Lipton, Richard (24 September 2011). "Rabin Flips a Coin" (http://rjlipton.wordpress.com/20
09/03/01/rabin-flips-a-coin/). Gödel's Lost Letter and P=NP.
5. Fortune, Steve; Hopcroft, John (1979). "A note on Rabin's nearest-neighbor algorithm".
Information Processing Letters. 8 (1): 20–23. doi:10.1016/0020-0190(79)90085-1 (https://doi.
org/10.1016%2F0020-0190%2879%2990085-1). hdl:1813/7460 (https://hdl.handle.net/181
3%2F7460). MR 0515507 (https://mathscinet.ams.org/mathscinet-getitem?mr=0515507).
6. Clarkson, Kenneth L. (1983). "Fast algorithms for the all nearest neighbors problem". 24th
Annual Symposium on Foundations of Computer Science, Tucson, Arizona, USA, 7-9
November 1983. IEEE Computer Society. pp. 226–232. doi:10.1109/SFCS.1983.16 (https://
doi.org/10.1109%2FSFCS.1983.16).
7. Cormen, Thomas H.; Leiserson, Charles E.; Rivest, Ronald L.; Stein, Clifford (2001) [1990].
"33.4: Finding the closest pair of points". Introduction to Algorithms (2nd ed.). MIT Press and
McGraw-Hill. pp. 957–961. ISBN 0-262-03293-7.
8. Kleinberg, Jon M.; Tardos, Éva (2006). "5.4 Finding the closest pair of points". Algorithm
Design. Addison-Wesley. pp. 225–231. ISBN 978-0-321-37291-8.
9. Golin, Mordecai; Raman, Rajeev; Schwarz, Christian; Smid, Michiel (1998). "Randomized
data structures for the dynamic closest-pair problem" (http://repository.ust.hk/ir/bitstream/178
3.1-1429/1/27771.pdf) (PDF). SIAM Journal on Computing. 27 (4): 1036–1072.
doi:10.1137/S0097539794277718 (https://doi.org/10.1137%2FS0097539794277718).
MR 1622005 (https://mathscinet.ams.org/mathscinet-getitem?mr=1622005). S2CID 1242364
(https://api.semanticscholar.org/CorpusID:1242364).
10. Bespamyatnikh, S. N. (1998). "An optimal algorithm for closest-pair maintenance" (https://do
i.org/10.1007%2FPL00009340). Discrete & Computational Geometry. 19 (2): 175–195.
doi:10.1007/PL00009340 (https://doi.org/10.1007%2FPL00009340). MR 1600047 (https://m
athscinet.ams.org/mathscinet-getitem?mr=1600047).

Retrieved from "https://en.wikipedia.org/w/index.php?title=Closest_pair_of_points_problem&oldid=1157523601"