Scribd
Upload
49 views12 pages

CMSC 451: Closest Pair of Points: Slides By: Carl Kingsford

This document describes an algorithm for finding the closest pair of points in a set of points in O(n log n) time. It first divides the points into two halves recursively, finding the closest pairs within each half. It then examines any points near the dividing line that may be closer than the closest pairs found so far. By sorting these points by y-coordinate and only checking each point against the next 15 points, it can perform this check in linear time. This yields an overall runtime of O(n log n) using the recursive divide and conquer approach.

Uploaded by

nitish verma
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
49 views12 pages

CMSC 451: Closest Pair of Points: Slides By: Carl Kingsford

This document describes an algorithm for finding the closest pair of points in a set of points in O(n log n) time. It first divides the points into two halves recursively, finding the closest pairs within each half. It then examines any points near the dividing line that may be closer than the closest pairs found so far. By sorting these points by y-coordinate and only checking each point against the next 15 points, it can perform this check in linear time. This yields an overall runtime of O(n log n) using the recursive divide and conquer approach.

Uploaded by

nitish verma
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 12

CMSC 451: Closest Pair of Points

Slides By: Carl Kingsford

Department of Computer Science


University of Maryland, College Park

Based on Section 5.4 of Algorithm Design by Kleinberg & Tardos.


Finding closest pair of points

Problem
Given a set of points {p1 , . . . , pn } find the pair of points {pi , pj }
that are closest together.
Goal

• Brute force gives an O(n2 ) algorithm: just check ever pair of


points.

• Can we do it faster? Seems like no: don’t we have to check


every pair?

• In fact, we can find the closest pair in O(n log n) time.

• What’s a reasonable first step?


Divide

Split the points with line L so that half the points are on each side.

Recursively find the pair of points closest in each half.

dleft

dright

L
Merge: the hard case

dleft

Let d = min{dleft , dright }.


dright

• d would be the answer, except maybe L split a close pair!


Region Near L

If there is a pair {pi , pj } with dist(pi , pj ) < d that is split by the


line, then both pi and pj must be within distance d of L.

d
L

Let Sy be an array of the points in that region, sorted by


decreasing y -coordinate value.
Slab Might Contain All Points

• Let Sy be an array of the points in that region, sorted by


decreasing y -coordinate value.

• Sy might contain all the points, so we can’t just check every


pair inside it.

Theorem
Suppose Sy = p1 , . . . , pm . If dist(pi , pj ) < d then j − i ≤ 15.

In other words, if two points in Sy are close enough in the plane,


they are close in the array Sy .
Proof, 1

Divide the region up into squares with sides of length d/2:

d/2

1 2 3
How many points in each box?
4 5 6 7

8 9 10 11

12 13 14 15
Proof, 1

Divide the region up into squares with sides of length d/2:

d/2

1 2 3
How many points in each box?
4 5 6 7
At most 1 because each box is
completely contained in one half
8 9 10 11
and no two points in a half are
closer than d.
12 13 14 15
Proof, 2

Suppose 2 points are separated by > 15 indices.

d/2
• Then, at least 3 full rows
1 2 3 separate them (the packing
shown is the smallest
4 5 6 7
possible).

8 9 10 11
• But the height of 3 rows is
> 3d/2, which is > d.
12 13 14 15
• So the two points are father
than d apart.
Linear Time Merge

Therefore, we can scan Sy for pairs of points separated by < d in


linear time.

ClosestPair(Px, Py):
if |Px| == 2: return dist(Px[1],Px[2]) // base

d1 = ClosestPair(FirstHalf(Px,Py)) // divide
d2 = ClosestPair(SecondHalf(Px,Py))
d = min(d1,d2)

Sy = points in Py within d of L // merge


For i = 1,...,|Sy|:
For j = 1,...,15:
d = min( dist(Sy[i], Sy[j]), d )
Return d
Total Running Time

Total Running Time:

• Divide set of points in half each time:


O(log n) depth recursion

• Merge takes O(n) time.

• Recurrence: T (n) ≤ 2T (n/2) + cn

• Same as MergeSort =⇒ O(n log n) time.

You might also like