GATE CS 2011 Question 23

This question deals with finding the closest pair of points in a given set of points in two dimensions.

Problem Statement

Given a set of n points in a plane, we wish to find a pair of points with the smallest Euclidean distance between them. Write a divide-and-conquer algorithm to find the closest pair of points among a set of n points.

Solution

We can solve this problem using a divide-and-conquer algorithm as follows:

1. Divide the set of n points into two equal-sized subsets by a vertical line at x=X.
2. Solve the problem recursively in the left and right subsets. This gives us the left-closest-pair distance dL and the right-closest-pair distance dR.
3. Let d be the minimum of dL and dR.
4. Determine the minimum distance dstrip in the strip that contains points from both left and right subsets.
5. Return the minimum of d and dstrip as the closest-pair distance.

The algorithm can be implemented using the following pseudocode:

closestPair(P)
  if n <= 3:
    return bruteForceClosestPair(P)
  
  mid = n / 2
  
  left = P[:mid]
  right = P[mid:]
  
  dL = closestPair(left)
  dR = closestPair(right)
  
  d = min(dL, dR)
  
  strip = []
  for point in P:
    if abs(point.x - mid.x) < d:
      strip.append(point)
  
  dstrip = stripClosestPair(strip, d)
  
  return min(d, dstrip)

The bruteForceClosestPair(P) function returns the closest-pair distance for a set of points using a brute-force algorithm. The stripClosestPair(strip, d) function returns the closest-pair distance for the points in the strip that are closer than d to the dividing line.

The time complexity of the algorithm is O(nlogn) due to the recursive divide-and-conquer approach. The space complexity is O(n) due to the creation of the left, right, and strip arrays.

Conclusion

In this question, we have discussed an algorithm to find the closest pair of points in a given set of points in two dimensions using a divide-and-conquer approach. The time complexity of the algorithm is O(nlogn) and the space complexity is O(n). This algorithm can be useful for applications such as computer vision and robotics that involve finding the closest pairs of points in a two-dimensional space.