寻找最近点对

问题：在空间中有n个点，寻找空间中最近的2个点。
法一：遍历，O（n^2）
法二：分治算法：
将点分为左右两半，分别找到最近的2个点，然后考虑交叉位置的点对中的最小距离，在这3者中取最小的那个。O（nlogn）。

步骤：
1. 按照x轴排序
2. 找到中间点，分别进行处理
3. 2边处理完成，将进行“merge”过程，先将点按照y轴升序，然后向上找7个点算距离比较即可，如果只看另一侧的话应该只有4个点，但是我们并没有进行分侧，故要算7个点才能保证把另一侧的算完 ，在一个边长为a的正方形内最多有4个点相互的距离大于等于a

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <stack>
#include <math.h>
#include <opencv\cv.h>
#include <opencv/highgui.h>

using namespace std;
using namespace cv;

#define INF 100000000


struct cp{
    Point a;
    Point b;
    float dis;
};

Point a[1000];
Point b[1000];
Point res[1000];

float calc_dis(Point a, Point b)
{
    return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}
struct cp mindiscp(Point *x, Point *y, int start, int end)
{
    cp temp_cp;
    if (end - start + 1 == 3)
    {
        float dis1 = calc_dis(x[start], x[start + 1]);
        float dis2 = calc_dis(x[start + 1], x[start + 2]);
        float dis3 = calc_dis(x[start], x[start + 2]);
        if (dis1 < dis2)
            if (dis1 < dis3)
            {
                temp_cp.a = x[start];
                temp_cp.b = x[start + 1];
                temp_cp.dis = dis1;
            }
            else
            {
                temp_cp.a = x[start];
                temp_cp.b = x[start + 2];
                temp_cp.dis = dis3;
            }
        else
        {
            temp_cp.a = x[start + 2];
            temp_cp.b = x[start + 1];
            temp_cp.dis = dis2;
        }
        return temp_cp;
    }
    if (end - start + 1 == 2)
    {
        temp_cp.a = x[start];
        temp_cp.b = x[end];
        temp_cp.dis = calc_dis(x[start], x[end]);
        return temp_cp;
    }

    int mid = (start + end) / 2;
    Point mid_p = x[mid];
    cp left_cp = mindiscp(x, y, 0, mid);
    cp right_cp = mindiscp(x, y, mid + 1, end);


    temp_cp = left_cp.dis < right_cp.dis ? left_cp : right_cp;
    Point in_dis_Point[1000];
    int k = 0;

    //找分界线距离在temp_cp.dis以内的点，并按y坐标升序 
    for (int i = 0; i < end - start + 1; i++)
        if ((y[i].x - mid_p.x <= temp_cp.dis) || (mid_p.x - y[i].x <= temp_cp.dis))
        {
            in_dis_Point[k++] = y[i];
        }
    //向上找7个点算距离比较即可，如果只看另一侧的话应该只有4个点，但是我们并没有进行分侧，故要算7个点才能保证把另一侧的算完 
    //在一个边长为a的正方形内最多有4个点相互的距离大于等于a 
    for (int i = 0; i < k; i++)
    {
        for (int j = i + 1; j < i + 8; j++)
        {
            Point p1 = in_dis_Point[i];
            Point p2 = in_dis_Point[j];
            float temp_dis = calc_dis(p1, p2);
            if (temp_cp.dis > temp_dis)
            {
                temp_cp.dis = temp_dis;
                temp_cp.a = p1;
                temp_cp.b = p2;
            }
        }
    }
    return temp_cp;
}

int cmpx(void const *a, void const *b)
{
    Point * c = (Point *)a;
    Point * d = (Point *)b;
    return c->x > d->x ? 1 : 0;
}

int cmpy(void const *a, void const *b)
{
    Point * c = (Point *)a;
    Point * d = (Point *)b;
    return c->y > d->y ? 1 : 0;
}

int K = 0;
Mat cor = Mat::zeros(1000, 1000, CV_8U);
void mouseHandler(int event, int x, int y, int ,void *param)
{
    switch (event)
    {
    case CV_EVENT_LBUTTONDOWN:
        a[K] = Point(x, y);
        b[K++] = Point(x, y);
        break;
    case CV_EVENT_LBUTTONUP:
        line(cor, Point(x, y), Point(x, y), Scalar(200), 20);
        imshow("a", cor);
        break;
    case CV_EVENT_RBUTTONDOWN:
        qsort(a, K, sizeof(Point), cmpx);
        qsort(b, K, sizeof(Point), cmpy);
        cp res = mindiscp(a, b, 0, K - 1);
        cout << res.a << res.b;
        line(cor, res.a, res.b, Scalar(200), 1);
        imshow("a", cor);
        break;
    }
}

int main()
{
    int num, res_num;
    namedWindow("a");
    imshow("a", cor);
    setMouseCallback("a", mouseHandler, 0);
    int c;
    while (c = cvWaitKey(33))
    {
        if (c == 27)//空格键
        {
            cor = Mat::zeros(1000, 1000, CV_8U);
            K = 0;
            imshow("a", cor);
        }
    }
}