使用分而治之算法的最近点对

最近点对问题是求平面上距离最近的两个点之间的距离的问题。分而治之算法也可以解决这个问题。该算法将平面点集按照X坐标排序，然后将点集分成两个子集。然后对每个子集递归进行求解，最后将得到每个子集中距离最近的点对，再在子集之间找到距离最近的点对。

算法实现

Python 代码实现

import math


def distance(point1, point2):
    """计算两点之间的距离"""
    return math.sqrt((point1[0] - point2[0]) ** 2 + (point1[1] - point2[1]) ** 2)


def brute_force(points, left, right):
    """暴力无章地解决此问题"""
    min_distance = float('inf')
    for i in range(left, right):
        for j in range(i + 1, right + 1):
            min_distance = min(min_distance, distance(points[i], points[j]))
    return min_distance


def closest_pair(points, left, right):
    """使用分而治之的方法解决最近点对问题"""
    if left >= right:
        return float('inf')
    elif left + 1 == right:
        return distance(points[left], points[right])

    mid = (left + right) // 2
    d1 = closest_pair(points, left, mid)
    d2 = closest_pair(points, mid + 1, right)
    d = min(d1, d2)

    # 跨越中间线的最小距离点对
    strip = []
    for i in range(left, right):
        if abs(points[mid][0] - points[i][0]) < d:
            strip.append(points[i])
    strip.sort(key=lambda x: x[1])

    # 检查跨越中间线的点对的距离
    for i in range(len(strip)):
        for j in range(i + 1, len(strip)):
            if strip[j][1] - strip[i][1] >= d:
                break
            d = min(d, distance(strip[i], strip[j]))

    return d


if __name__ == '__main__':
    points = [(1, 2), (5, 8), (2, 4), (2, 7), (6, 1), (4, 3), (3, 7)]
    points = sorted(points)
    print(closest_pair(points, 0, len(points) - 1))

Java 代码实现

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ClosestPair {

    private static double distance(Point point1, Point point2) {
        return Math.sqrt(Math.pow(point1.x - point2.x, 2) + Math.pow(point1.y - point2.y, 2));
    }

    private static double bruteForce(List<Point> points, int left, int right) {
        double minDistance = Double.POSITIVE_INFINITY;
        for (int i = left; i <= right; i++) {
            for (int j = i + 1; j <= right; j++) {
                minDistance = Math.min(minDistance, distance(points.get(i), points.get(j)));
            }
        }
        return minDistance;
    }

    private static double closestPair(List<Point> points, int left, int right) {
        if (left >= right) {
            return Double.POSITIVE_INFINITY;
        } else if (left + 1 == right) {
            return distance(points.get(left), points.get(right));
        }

        int mid = (left + right) / 2;
        double d1 = closestPair(points, left, mid);
        double d2 = closestPair(points, mid + 1, right);
        double d = Math.min(d1, d2);

        // 跨越中间线的最小距离点对
        List<Point> strip = new ArrayList<>();
        for (int i = left; i <= right; i++) {
            if (Math.abs(points.get(mid).x - points.get(i).x) < d) {
                strip.add(points.get(i));
            }
        }
        strip.sort((p1, p2) -> Integer.compare(p1.y, p2.y));

        // 检查跨越中间线的点对的距离
        for (int i = 0; i < strip.size(); i++) {
            for (int j = i + 1; j < strip.size() && strip.get(j).y - strip.get(i).y < d; j++) {
                d = Math.min(d, distance(strip.get(i), strip.get(j)));
            }
        }

        return d;
    }

    public static void main(String[] args) {
        List<Point> points = Arrays.asList(
                new Point(1, 2),
                new Point(5, 8),
                new Point(2, 4),
                new Point(2, 7),
                new Point(6, 1),
                new Point(4, 3),
                new Point(3, 7)
        );
        points.sort((p1, p2) -> Integer.compare(p1.x, p2.x));
        System.out.println(closestPair(points, 0, points.size() - 1));
    }

    private static class Point {
        int x;
        int y;

        Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}

算法分析

最近点对问题的分而治之算法的时间复杂度为$O(n\log n)$。最复杂的操作是将点集按X坐标排序，这需要$O(n \log n)$的时间。然后算法递归处理两个子集，将会有$2T(\frac{n}{2})$的执行时间。计算跨越中间线的点对之间的距离需要$O(n)$时间。因此，整个算法的时间复杂度为$T(n) = 2T(\frac{n}{2}) + O(n \log n)$。使用主定理可以证明$T(n) = O(n\log n)$。

参考文献

• Introduction to Algorithms, Third Edition. By Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest and Clifford Stein.
• Algorithm Design. By Jon Kleinberg and Éva Tardos.