算法-分治法-最近对问题

蛮力法的最近对问题：https://blog.csdn.net/qq_40452317/article/details/88040973

用分治法解决问题就是将集合s分为两个集合s1和s2。每个解合都有n/2个点，接着在子集和中递归求解最近的点。

一维情况

为了简单化问题，我们先考虑一维情形，即所有的点都在x轴上（假如顺序是有序的，也可以排好序，为简单，直接输入有序序列），x轴上某个点m将集合划分为s1和s2，并且两个集合的点数都是相同的，递归的求解两个子集最近对的点，(p1,p2)和(q1,q2)。如果，两个集合的最近点对都在子集s1和s2中，则

                                                          d = min{ |p1-p2| , |q1-q2| } 

如果，最近点对分别在s1和s2中，则一定是（p3,q3)。|p3-q3|<d，则p3和q3两者与m的距离都不超过d，且在区间(m-d,d]和(d,m+d]各有且仅有一个点。这样，就可以在线性时间内实现合并。

                       

一维情形下的最近点对时间复杂度为O(nlogn)。

二维情况

推广一维，来看二维，我们仿照一维的情况先把所有点按照x(横坐标)从左到右升序排列。以X横坐标中间的点作为分界线.将平面的点分成左边和右边。找到左边的点中最近点对的距离d1,和右边最近点对的距离d2。d=min{d1,d2}。如下如：

                    

当前的d1,d2都是两边各自的点的最近距离,但是没有考虑到两边的点相互配对的情况,即是点对一个在左边区域,一个在右边区域。可以用上面找到的d来限制配对.即是明显超过d的两点不需要配对，如下

                                               

以中间线为中心，dmin 为半径划分一个长带，最小点对还有可能存在于s1和s2的交界处，，p点和q点分别位于S1和S1的虚线范围内，只有在这个范围内，p点和q点之间的距离才会小于dmin。

不选取2dmin 带中所有的点进行计算，而是对于S1虚框范围内的p点，只选取S2虚框范围内长2dmin，宽为dmin的中的点进行计算，由dmin的意义可知S2中任何2个S中的点的距离都不小于d。由此可以推出矩形R中最多只有6个S2中的点。

 

                                                 

为什么只有六个点？

我们利用反证法证明：

如果右边这2个正方形内有7个点与p点距离小于d，例如q点，则q点与下面正方形的四个顶点距离小于d，则和d为S1和S2中的最小点对距离相矛盾。因此对于S1虚框中的p点，不需求出p点和右边虚线框内所有点距离，只需计算S2中与p点y坐标距离最近的6个点，就可以求出最近点对，节省了比较次数。

                          

然后我们只知道对于S1中每个d中的点p最多只需要检查S2中的6个点，但是我们并不确切地知道要检查哪6个点。为了解决这个问题，我们可以将p和S2中所有d的点投影到中界线上。由于能与p点一起构成最接近点对候选者的d中点一定在矩形R中，所以它们在直线l上的投影点距p在中界限上投影点的距离小于d。由上面的分析可知，这种投影点最多只有6个。因此，若将S1和S2中所有S的点按其y坐标排好序，则对S1中所有点p，对排好序的点列作一次扫描，就可以找出所有最接近点对的候选者，对S1中每一点最多只要检查S2中排好序的相继6个点。

算法代码

一、输入：按x坐标排列的n(n>=2)个点的集合S={(x1,y1),(x2,y2),...,(xn,yn)}

1.如果n==2，则返回（x1,y1）和（x2,y2）之间的距离，算法结束；

2.如果n==3，则返回（x1,y1）、（x2,y2）和（x3,y3）之间的最小距离，算法结束；（此步必要在于，若n==3划分之后必然有一半为n==1，导致无法正确执行递归）

3.划分：m==S中各点x坐标的中位数；

4.d1 = 计算{(x1,y1),...,(xm,ym)}的最近对距离；

5.d2 = 计算{(xm,ym),...,(xn,yn)}的最近对距离；

6.d = min(d1,d2);

7.依次考察集合S中的点p（x，y），如果（x<=xm 并且x>=xm-d），则将点p放入集合P1中；如果（x>xm 并且x<=xm+d），则将点p放入集合P2中;

8.将集合P1和P2按y坐标升序排列；

9.对集合P1和P2中的每个点p（x，y），在y坐标区间[y,y+d]内最对取出6个候选点，计算与点p的最近距离d3；

10.返回min{d，d3}；

二、输出：最近点的距离

蛮力法

（手动输入的时候也会占用时间，所以用文件输入）https://blog.csdn.net/qq_40452317/article/details/88040973： 

                              

 

现在使用分治法：

sort排序的函数使用方法：https://www.cnblogs.com/TX980502/p/8528840.html

#include<iostream>
#include<math.h>  //计算距离
#include<time.h>  //计算运行时间
#include<fstream>  //文件操作
#include<algorithm>  //排序

using namespace std;
#define MAX 0x3f3f3f3f  //定义无穷大
#define M 99999

struct point {
  double x, y;
}p[M];
 
int a[M];// 保存排序的索引
 
int cmpx(const point& a, const point& b)  //排序升序
{  
  return a.x < b.x;
}
 
int cmpy(int &a, int &b)   //排序升序
{
  return p[a].y < p[b].y;
}
 
inline double min(double a, double b)   //返回两个值中较小的
{
	return a < b ? a : b;
}
inline double dist(const point& a, const point& b)
{
  return sqrt((a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y));
}
double closeset(int low, int high)
{
	if (low == high)   
		return MAX;
	if (low + 1 == high)  //即n=2，返回两点之间的距离
		return dist(p[low], p[high]);
	int mid = (low + high)>>1;  //右移一位，相当于除以2，但右移的运算速度更快，若使用(low+high)/2求中间位置容易溢出
	double ans = min(closeset(low, mid), closeset(mid+1, high));  //递归求出两边最小距离
	int i, j, c = 0;
	for (i = low; i <= high; i++) //统计那些点位于两虚线内，并记录
	{
		if (p[mid].x - ans <= p[i].x && p[i].x <= p[mid].x + ans)
			a[c++] = i;
	}
	sort(a, a + c, cmpy);
	for(i = 0; i < c; i++)//比较s1中虚线内的点和s2中虚线内的点的距离是否存在有小于两侧最小对的
	{
		int k = i+7 > c ? c : i+7;  
		for (j = i+1; j < k; j++)
		{
			if (p[a[j]].y - p[a[i]].y > ans)  //如果位于中位线两侧的点的距离大于anx则跳出第一个循环
				break;
			ans = min(dist(p[a[i]], p[a[j]]), ans);   //如果有两个点小于两侧的最近对，则选出最小的点
		}
	}
	return ans;
}

int main()
{
	clock_t start;
	double totaltime;
	start=clock();
	int n;  //一共多少个点
	double dmin;
	ifstream read_in;
	read_in.open("close.txt");
	read_in >> n;
	cout<<"读入点数为："<<n<<endl;
	cout<<"点的坐标为："<<endl;
	for(int i=0;i<n;i++)  //循环读入文件
	{
		cout<<"p"<<i+1<<":";
		read_in>>p[i].x>>p[i].y;
		cout<<p[i].x<<" "<<p[i].y<<endl;
	}
	sort(p,p+n,cmpx); //按照x轴排序
	dmin=closeset(0, n-1);
	cout<<"最近的距离是："<<dmin<<endl;
	clock_t end=clock();
	totaltime=(double)(end-start)/CLOCKS_PER_SEC;
	cout<<"程序运行时间是："<<totaltime<<endl;
	return 0;
}

                               

 

可以看出，分治法的时间是0.008，蛮力法的时间是0.012。如果点数达到一定多，效率更加明显。