最近点对问题

法一：蛮力法

法二：分治法

 

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include<windows.h>
#include<sys\timeb.h>
using namespace std;

long long getSystemTime(){
	timeb t;
	ftime(&t);
	return t.time * 1000 + t.millitm;
}
struct Point
{
	double x = 0;
	double y = 0;
};
double force_get_min(struct Point *P,int n)
{
    double mmin, t;
	mmin = (P[0].x - P[1].x)*(P[0].x - P[1].x) + (P[0].y - P[1].y)*(P[0].y - P[1].y);
	for (register int i = 0; i<n - 1; i++)
	{
		for (register int k = i + 1; k<n; k++)
		{
			t = (P[k].x - P[i].x)*(P[k].x - P[i].x) + (P[k].y - P[i].y)*(P[k].y - P[i].y);
			if (mmin>t)
				mmin = t;
		}
	}
	return sqrt(mmin);
}
void sort_x_point(struct Point *P, int left, int right)
{
	Point temp;
	if (right - left>0)
	{
		int i = left, j = right, flag = 0;
		while (i<j)
		{
			if (P[i].x>P[j].x)
			{
				temp = P[i];
				P[i] = P[j];
				P[j] = temp;
				if (flag == 0)
				{
					i++;
					flag = 1;
				}
				else
				{
					j--;
					flag = 0;
				}
			}
			else
			{
				if (flag == 0)
				{
					j--;
				}
				else
				{
					i++;
				}
			}
		}
		sort_x_point(P, left, i - 1);
		sort_x_point(P, i + 1, right);
	}
}
void sort_y_point(struct Point *P, int left, int right)
{
	Point temp;
	if (right - left>0)
	{
		int i = left, j = right, flag = 0;
		while (i<j)
		{
			if (P[i].y>P[j].y)
			{
				temp = P[i];
				P[i] = P[j];
				P[j] = temp;
				if (flag == 0)
				{
					i++;
					flag = 1;
				}
				else
				{
					j--;
					flag = 0;
				}
			}
			else
			{
				if (flag == 0)
				{
					j--;
				}
				else
				{
					i++;
				}
			}
		}
		sort_y_point(P, left, i - 1);
		sort_y_point(P, i + 1, right);
	}
}

double get_distance(struct Point P,struct Point Q)
{
    return (P.x-Q.x)*(P.x-Q.x)+(P.y-Q.y)*(P.y-Q.y);
}



double dc_get_min(struct Point *P, int left, int right)
{
	if (right - left == 2)
	{
		double t1, t2, t3, t;
		t1 = get_distance(P[left],P[left+1]);
		t2 = get_distance(P[left+1],P[left+2]);
		t3 = get_distance(P[left],P[left+2]);
		t = t1 < t2 ? t1 : t2;
		t = t < t3 ? t : t3;
		return t;
	}
	if (right - left == 1)
		return get_distance(P[left],P[left+1]);
	if (left == right)
		return 100000000000000000000;

	double mid_x = 0;
	mid_x = P[(right + left) / 2].x;

	int loc_i, left_i, right_i;
	loc_i = (right + left) / 2 + 1;

	double left_min, right_min;

	left_min = dc_get_min(P, left, loc_i - 1);
	right_min = dc_get_min(P, loc_i, right);

	double mmin = left_min<right_min ? left_min : right_min;
	double temp_t;
	for (left_i = left; left_i<loc_i; left_i++)
	{
		if (mid_x - P[left_i].x < mmin)
			break;
	}
	for (right_i = right; right_i >= loc_i; right_i--)
	{
		if (P[right_i].x - mid_x < mmin)
			break;
	}

	sort_y_point(P, loc_i, right_i);

	for (int i = left_i; i<loc_i; i++)
	{
		for (int k = loc_i; k <= right_i; k++)
		{
			if (P[i].y - P[k].y > mmin)
				continue;
			if (P[k].y - P[i].y > mmin)
				break;
			temp_t = get_distance(P[k],P[i]);
			if (temp_t<mmin)
				mmin = temp_t;
		}
	}
	return mmin;
}

int main()
{
	int countt = 0;
	int a[10]={100000,200000,300000,400000,500000,600000,700000,800000,900000,1000000};
	struct Point *A=new struct Point[1000001];
	struct Point temp;
	double force_get_m = 0, dc_get_m = 0;
	double time = 0, total_time = 0;
	long long t1,t2;
    for(int k=0;k<10;k++)
    {
        cout<<"数据规模为："<<a[k]<<endl;
        for (int i = 0; i < a[k]; i++)
        {
            A[i].x = rand() % 10000000;
            A[i].y = rand() % 10000000;
        }
        t1 = clock();
        force_get_m = force_get_min(A,a[k]);
        t2 = clock();
        cout << "蛮力法时间为："<< "      "<< t2 - t1 << "ms"<<"      ";

        t1 = clock();
        sort_x_point(A,0,a[k]-1);
        dc_get_m = sqrt(dc_get_min(A,0,a[k]-1));
        t2 = clock();
        cout << "分治法时间为："<< "      "<< t2 - t1 <<"ms"<<endl<<endl;
    }
	delete [] A;
	return 0;
}