最近对距离（分治法） OJ-794

Tags: 分治法

设p1=(x1, y1), p2=(x2, y2), …, pn=(xn, yn)是平面上n个点构成的集合S，设计算法找出集合S中距离最近的点对。

输入

多组测试数据，第一行为测试数据组数n（0<n≤100），每组测试数据由两个部分构成，第一部分为一个点的个数m（0<m≤1000），紧接着是m行，每行为一个点的坐标x和y，用空格隔开，（0<x，y≤100000）

输出

每组测试数据输出一行，为该组数据最近点的距离，保留4为小数。

样例输入

2 2 0 0 0 1 3 0 0 1 1 1 0

样例输出

1.0000 1.0000

解释：当区域内点在3及3以下时 直接计算。3以上则分治。最后再在分割线左右符合距离的点计算

#include <iostream>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <math.h>
using namespace std;

const int M = 1000+10;

#define unlimited 100010*2;//开始没有乘2导致WrongAnswer 原因: x,y的范围是0-100000.如果p1=(0,0)p2=(100000,100000) distance是等于100000√2的。所以这里约定大一点
//用结构体储存点
struct point{
    float x,y;
}poi[M];
//sort比较函数
bool cmp(point p1,point p2){
    return p1.x<p2.x;
}

//比较返回三个点的最短距离
float nearestDistanceOfThreePoint(int l,int r){
    float temp = ((poi[l+1].x-poi[l].x)*(poi[l+1].x-poi[l].x) + (poi[l+1].y-poi[l].y)*(poi[l+1].y-poi[l].y));
    float temp2 = ((poi[l+2].x-poi[l+1].x)*(poi[l+2].x-poi[l+1].x) + (poi[l+2].y-poi[l+1].y)*(poi[l+2].y-poi[l+1].y));
    temp = temp<temp2?temp:temp2;
    temp2 = ((poi[l+2].x-poi[l].x)*(poi[l+2].x-poi[l].x) + (poi[l+2].y-poi[l].y)*(poi[l+2].y-poi[l].y));
    temp = temp<temp2?temp:temp2;
    return temp;
}


float minDistance = unlimited;
float d1,d2,d3,dividedLine;
//存放分割线左右边符合条件的点
vector<point>leftPoints;
vector<point>rightPoints;
float nearestPointDistance(int l,int r){
    //一个点
    if(r-l == 0)    return unlimited;
    //两个点
    if(r-l == 1)    return ((poi[r].x-poi[l].x)*(poi[r].x-poi[l].x) + (poi[r].y-poi[l].y)*(poi[r].y-poi[l].y));
    //三个点
    if(r-l == 2)    return nearestDistanceOfThreePoint(l, r);
    //三个点以上则需要递归分治
    else{
        d1 = nearestPointDistance(l, (l+r)/2);
        d2 = nearestPointDistance((l+r)/2+1, r);
        dividedLine = (poi[(l+r)/2+1].x+poi[(l+r)/2].x)/2;//分界线
        d3 = d1>d2?d2:d1;
        minDistance = d3<minDistance?d3:minDistance;
        leftPoints.clear();
        rightPoints.clear();
        for (int i = l ; i <= (l+r)/2 ;  i++ ) {
            if(minDistance > (dividedLine-poi[i].x)*(dividedLine-poi[i].x))
                leftPoints.push_back(poi[i]);
        }
        for (int i = (l+r)/2+1; i <= r ; i++ ) {
            if (minDistance > (poi[i].x-dividedLine)*(poi[i].x-dividedLine)) {
                rightPoints.push_back(poi[i]);
            }
        }
        for(vector<point>::iterator left = leftPoints.begin() ; left!=leftPoints.end() ; left ++){
            for (vector<point>::iterator right = rightPoints.begin() ; right != rightPoints.end(); right++ ) {
                if ((right->x - left->x)*(right->x - left->x) >= minDistance)  continue;
                if ((right->y - left->y)*(right->y - left->y) >= minDistance)  continue;
                if ((left->y - right->y)*(left->y - right->y) >= minDistance)  continue;
                float temp = ((right->y-left->y)*(right->y-left->y) + (right->x-left->x)*(right->x-left->x));
                minDistance = temp<minDistance?temp:minDistance;
            }
        }
        
    }
    return minDistance;
}

int main()
{
    std::ios::sync_with_stdio(false);//取消cin同步，我们知道scanf和cin的速度不一样。这句话就很大程度提升cin的速度。
    int n,m;
    cin>>n;
    while (n--) {
        cin>>m;
        for(int i = 0 ; i < m ; i++)
            cin>>poi[i].x>>poi[i].y;
        sort(poi,poi+m,cmp);
        minDistance = unlimited;
        //setprecision（4）是保留4位有效数字。fixed 是从小数点之后。
        cout<<fixed<<setprecision(4)<<sqrt(nearestPointDistance(0, m-1))<<endl;;
    }
    return 0;
}