分治法求最近点对（Closest Pair of Points）

最新推荐文章于 2024-04-07 10:39:48 发布

RRRRRoyal

最新推荐文章于 2024-04-07 10:39:48 发布

阅读量1.9k

点赞数 24

文章标签：算法

本文链接：https://blog.csdn.net/m0_73916791/article/details/135218644

版权

分治法求最近点对（Closest Pair of Points）是一种解决平面上最近点对问题的常用算法，其基本思想如下：

首先，将所有的点按照 x 坐标进行排序，得到一个按照 x 坐标有序的点集。
然后利用分治法，将平面上的点集分成两部分，分别找到左右两边的最近点对。
记左半部分的最近点对为 (p1, q1)，右半部分的最近点对为 (p2, q2)，则距离 d1 = dist(p1, q1) 和 d2 = dist(p2, q2) 是左右两边的最近点对的距离。
然后，考虑跨分界线的点对，对于每一个点 p，只需要考虑距离 p 在 x 轴上距离小于 d 的点 q，计算这样的点对的距离，并选择最小的距离作为最终的跨分界线的最近点对距离 dmin。
最后，比较 d1、d2 和 dmin，取最小值作为最终的最近点对的距离。

在实际实现中，可以采用递归算法来实现该思想。具体实现时，需要注意合并过程中的复杂度控制，通常可以在合并步骤中利用空间换时间的思想来降低算法的复杂度。

分治法求最近点对的时间复杂度为 O(nlogn)，其中 n 是平面上的点的数量。这个算法在实际应用中被广泛使用，并且在计算几何领域有着重要的意义。
以下是分治法求最近点对的 C++ 面向过程代码：

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;

struct Point {
    int x, y;
};

bool compareX(const Point& a, const Point& b) {
    return a.x < b.x;
}

bool compareY(const Point& a, const Point& b) {
    return a.y < b.y;
}

float distance(const Point& a, const Point& b) {
    return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

float bruteForceClosestPair(vector<Point>& points, int start, int end) {
    float minDist = numeric_limits<float>::max();
    for (int i = start; i < end; ++i) {
        for (int j = i + 1; j < end; ++j) {
            minDist = min(minDist, distance(points[i], points[j]));
        }
    }
    return minDist;
}

float closestPairUtil(vector<Point>& pointsByX, vector<Point>& pointsByY, int start, int end) {
    if (end - start <= 3) {
        return bruteForceClosestPair(pointsByX, start, end);
    }

    int mid = (start + end) / 2;
    Point midPoint = pointsByX[mid];

    vector<Point> leftPointsByY, rightPointsByY;
    for (const Point& p : pointsByY) {
        if (p.x <= midPoint.x) {
            leftPointsByY.push_back(p);
        } else {
            rightPointsByY.push_back(p);
        }
    }

    float leftClosest = closestPairUtil(pointsByX, leftPointsByY, start, mid);
    float rightClosest = closestPairUtil(pointsByX, rightPointsByY, mid, end);
    float minDist = min(leftClosest, rightClosest);

    vector<Point> strip;
    for (const Point& p : pointsByY) {
        if (abs(p.x - midPoint.x) < minDist) {
            strip.push_back(p);
        }
    }

    for (int i = 0; i < strip.size(); ++i) {
        for (int j = i + 1; j < strip.size() && (strip[j].y - strip[i].y) < minDist; ++j) {
            minDist = min(minDist, distance(strip[i], strip[j]));
        }
    }

    return minDist;
}

float closestPair(vector<Point>& points) {
    vector<Point> pointsByX = points;
    vector<Point> pointsByY = points;
    sort(pointsByX.begin(), pointsByX.end(), compareX);
    sort(pointsByY.begin(), pointsByY.end(), compareY);
    return closestPairUtil(pointsByX, pointsByY, 0, points.size());
}

int main() {
    vector<Point> points = {{1, 1}, {3, 4}, {5, 2}, {7, 6}, {8, 1}, {9, 5}};
    cout << "最近点对的距禶是：" << closestPair(points) << endl;
    return 0;
}