算法-最近点匹配

题目要求：

• 主要部分：平面内有n个点，设计算法找出这那个点中距离最近点对的距离。
• 附加要求：输入总点数n，随机生成n个点

思路

1.主要思路

1. 输入
2. 预处理
3. 递归查找
4. 输出

2.递归分析

具体看视频讲解：北大屈老师的

选取中线将平面内的点划分为两个部分

这样就会产生距离最短两种情况

1. 两个点都在中线两边，这个好办用分治递归处理
2. 两个点分别在中线两边，这个是算法的难点

针对第二种情况进行分析

d = min(左边最短的距离，右边最短的距离)
p1为左边的点
p2为右边的点

1. 与分割线L的距离超过d的排除
2. P1,P2纵坐标之差小于d。
   
   
   因此在这种情况下对每个P1来说满足条件的最多6个点
   这样时间效率就会相对提高

相关代码

    //分离出离中线距离小于d的点
    for (i = left; i <= right; i++)
    {
        if (fabs(point[mid].x - point[i].x) <= d)
            mpt[k++] = i;
    }
    //对y排序
    sort(mpt, mpt + k, cmpy);
    //线性扫描
    for (i = 0; i < k; i++)
    {
        for (j = i + 1; j < k && point[mpt[j]].y - point[mpt[i]].y < d; j++){
            double d3 = dis(mpt[i], mpt[j]);
            if (d > d3)
                d = d3;
        }
    }

代码改进

要做到预处理
也就是在main函数的时候就优先对x与y排序
节省后续在每次执行分治的时候重复排序

1. 简单的预处理
   在主函数中仅仅优先对x排序，不加深对y的排序
   在分治函数中再对y进行排序
   最终这个算法的时间复杂度是T(n)=O(nlog²n)
2. 加深预处理
   在main中排序时将x与y拆分排序
   在分治拆分的时候在将y选择性并入两个不同子集
   
   最终这个算法的时间复杂度是T(n)=O(nlogn)

代码示例

#include <iostream>  
#include <cstdio>  
#include <cstdlib>
#include <cstring>  
#include <cmath>
#include <ctime>
#include <algorithm>  
using namespace std;
const double inf = 1e20;
const int maxn = 100005;

struct Point
{
    double x, y;
}point[maxn];

int n, mpt[maxn];


//x为基准排序，在x相同的情况下排y
bool cmpxy(const Point& a, const Point& b)
{
    if (a.x != b.x)
        return a.x < b.x;
    return a.y < b.y;
}

//对y进行排序
bool cmpy(const int& a, const int& b)
{
    return point[a].y < point[b].y;
}

//寻找最小值
double min(double a, double b)
{
    return a < b ? a : b;
}

//距离计算
double dis(int i, int j)
{
    return sqrt((point[i].x - point[j].x)*(point[i].x - point[j].x) + (point[i].y - point[j].y)*(point[i].y - point[j].y));
}

//最近点匹配(传入当前最左和最右)
double Closest_Pair(int left, int right)
{
    //d为最小距离
    double d = inf;

    //递归出口
    if (left == right)
        return d;
    if (left + 1 == right)
        return dis(left, right);
    
    //位运算求中值
    int mid = (left + right) >> 1;

    //递归
    double d1 = Closest_Pair(left, mid);
    double d2 = Closest_Pair(mid + 1, right);

    d = min(d1, d2);
    int i, j, k = 0;

    //分离出离中线距离小于d的点
    for (i = left; i <= right; i++)
    {
        if (fabs(point[mid].x - point[i].x) <= d)
            mpt[k++] = i;
    }
    sort(mpt, mpt + k, cmpy);

    //线性扫描
    for (i = 0; i < k; i++)
    {
        for (j = i + 1; j < k && point[mpt[j]].y - point[mpt[i]].y < d; j++){
            double d3 = dis(mpt[i], mpt[j]);
            if (d > d3)
                d = d3;
        }
    }
    return d;
}

//随机生成点
void CreatePoints()
{
    //随机化随机数种子
	srand(time(NULL));
	for (int i = 0; i<n; i++)
    {
		point[i].x = rand()%10000/(double)100;
		point[i].y = rand()%10000/(double)100;

		//每1000个数据乘以一个特定的数，将数据尽量分散，减少重复
		point[i].x *= ((i / 1000) + 1);
		point[i].y *= ((i / 1000) + 1);

		//遍历已经生成的所有点，一旦发现重合则重新生成该点
		for (int j = 0; j < i; j++){
			if (point[j].x == point[i].x && point[j].y == point[i].y) {
				i--;
				break;
			}
		}
        printf("(%.2lf, %.2lf)\t", point[i].x, point[i].x);
        if ((i+1)%5==0||i==n-1)
        {
            printf("\n");
        }
	}
}
int main()
{
    //输入
    while(~scanf("%d",&n)&&n)
    {   
        if(n==1)
        {
            printf("最小距离：0\n");
            continue;
        }

        //生成n对x/y的值
        CreatePoints();

        //对x/y排序
        sort(point, point + n, cmpxy);

        //利用分治，输出最小距离
        printf("最小距离：%.2lf\n", Closest_Pair(0, n - 1) / 2);
    }
    
    return 0;
}

输出效果图