用分治算法解平面最接近点对问题
0007算法笔记——【分治法】最接近点对问题
问题场景：在应用中，常用诸如点、圆等简单的几何对象代表现实世界中的实体。
在涉及这些几何对象的问题中，常需要了解其邻域中其他几何对象的信息。
例如，在空中交通控制问题中，若将飞机作为空间中移动的一个点来看待，则具有最大碰撞危险的2架飞机，就是这个空间中最接近的一对点。
这类问题是计算几何学中研究的基本问题之一。
问题描述：给定平面上n个点，找其中的一对点，使得在n个点的所有点对中，该点对的距离最小。
严格地说，最接近点对可能多于1对。
为了简单起见，这里只限于找其中的一对。
1、一维最接近点对问题算法思路：这个问题很容易理解，似乎也不难解决。
我们只要将每一点与其他n-1个点的距离算出，找出达到最小距离的两个点即可。
然而，这样做效率太低，需要O(n^2)的计算时间。
在问题的计算复杂性中我们可以看到，该问题的计算时间下界为Ω(nlogn)。
这个下界引导我们去找问题的一个θ(nlogn)算法。
采用分治法思想，考虑将所给的n个点的集合S分成2个子集S1和S2，每个子集中约有n/2个点，然后在每个子集中递归地求其最接近的点对。
在这里，一个关键的问题是如何实现分治法中的合并步骤，即由S1和S2的最接近点对，如何求得原集合S中的最接近点对，因为S1和S2的最接近点对未必就是S 的最接近点对。
如果组成S的最接近点对的2个点都在S1中或都在S2中，则问题很容易解决。
但是，如果这2个点分别在S1和S2中，则对于S1中任一点p，S2中最多只有n/2个点与它构成最接近点对的候选者，仍需做n^2/4次计算和比较才能确定S的最接近点对。
因此，依此思路，合并步骤耗时为O(n^2)。
整个算法所需计算时间T(n)应满足:T(n)=2T(n/2)+O(n^2)。
它的解为T(n)=O(n^2)，即与合并步骤的耗时同阶，这不比用穷举的方法好。
从解递归方程的套用公式法，我们看到问题出在合并步骤耗时太多。
这启发我们把注意力放在合并步骤上。
设S中的n个点为x轴上的n个实数x1,x2,..,xn。
最接近点对问题教材
S2中的q3组成，则p3和q3一定在划分平面 L的距离d内。
第二步筛选：考虑P1中任意一点p，它若与
P2中的点q构成最接近点对的候选者，则必 有distance(p，q)＜d。满足这个条件的P2 中的点定落在一个d×2d×2d的长方体R中
重要观察结论：P2中任何2个S中的点的距离 都不小于d。由此可以推出长方体R中最多只有 24个S中的点。
分治法解决二维空间最接近点问题
选取一垂直线l:x=m来作为分割直线。其中m为S中各 点x坐标的中位数。由此将S分割为S1和S2。 递归地在S1和S2上找出其最小距离d1和d2，并设 d=min{d1,d2}，S中的最接近点对或者是d，或者是某个 {p,q}，其中p∈S1且q∈S2。
第一步筛选：如果最近点对由S1中的p3和
4、设P1是S1中距垂直分割线l的距离在dm之 内的所有点组成的集合； { P2是S2中距分割线l的距离在dm之内所有 n=|S|; 点组成的集合； O(n) 将 P1 和 P2 中点依其 y 坐标值排序； if (n < 2) return ; 并设X和Y是相应的已排好序的点列； 1、m=S中各点x间坐标的中位数; 5、通过扫描X以及对于X中每个点检查Y中与 构造S1和S2； 其距离在dm之内的所有点(最多6个)可以完成 O(n) 合并； O(n) //S1={p∈S|x(p)<=m}, 当X中的扫描指针逐次向上移动时，Y中的 S2={p∈S|x(p)>m} 扫描指针可在宽为2dm的区间内移动； 2、d1=cpair2(S1); 设dl是按这种扫描方式找到的点对间的最 2T(n/2 小距离； d2=cpair2(S2); ) 6、d=min(dm,dl); 常数时间 3、dm=min(d1,d2); return d; 常数时间 }
平面最接近点对问题（分治法）
平⾯最接近点对问题（分治法）头⽂件部分：（1）数据结构部分：//涉及的数据结构#ifndef DATASET_H#define DATASET_Hstruct point{ //点结构double x, y;};#endif（2）函数声明部分：//函数头⽂件//=======================================#ifndef FUNC_H#define FUNC_H#include "dataset.h"double closest_distance(point s[], int low, int high, point rec[]);double Distance(point a, point b);bool comp_x(point a, point b);bool comp_y(point a, point b);#endif源⽂件部分：（1）函数实现部分：//求解最近距离的函数实现#include "dataset.h"#include <math.h>#include <algorithm>using namespace std;double Distance(point a, point b) //计算两点距离{return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) - (a.y - b.y));}bool comp_x(point a, point b) //按x升序判别函数{return a.x < b.x;}bool comp_y(point a, point b) //按y升序判别函数{return a.y < b.y;}//函数实现：rec[]存储最接近点对；double closest_distance(point s[], int low, int high, point rec[]){double d1, d2, d3, d;int mid, i, j, index;double x1, y1, x2, y2; //记录最近的点对point *P = new point[high - low + 1];point temp_1[2], temp_2[2], temp_3[2];if (high - low == 1) //两个点时的情况{rec[0].x = s[low].x; rec[0].y = s[low].y;rec[1].x = s[high].x; rec[1].y = s[high].y;return Distance(s[low], s[high]);}if (high - low == 2) //三个点时的情况{d1 = Distance(s[low], s[low + 1]);d2 = Distance(s[low + 1], s[high]);d3 = Distance(s[low], s[high]);if ((d1 <= d2) && (d1 <= d3)) //这⾥在判断三种情况时，第⼆种情况没必要使⽤(d2<d3)&&(d2<d1),相较更繁琐了；{rec[0].x = s[low].x; rec[0].y = s[low].y;rec[1].x = s[low + 1].x; rec[1].y = s[low + 1].y;return d1;}else if (d2 < d3){rec[0].x = s[low + 1].x; rec[0].y = s[low + 1].y;rec[1].x = s[high].x; rec[1].y = s[high].y;return d2;}else{rec[0].x = s[low].x; rec[0].y = s[low].y;rec[1].x = s[high].x; rec[1].y = s[high].y;return d3;}}mid = (low + high) / 2;d1 = closest_distance(s, low, mid, rec);temp_1[0] = rec[0];temp_1[1] = rec[1];d2 = closest_distance(s, mid + 1 ,high, rec);temp_2[0] = rec[0];temp_2[1] = rec[1];if (d1 <= d2){d = d1;rec[0] = temp_1[0];rec[1] = temp_1[1];}else{d = d2;rec[0] = temp_2[0];rec[1] = temp_2[1];}index = 0;for (i = mid; (i >= low) && ((s[mid].x - s[i].x) < d); i--){P[index++] = s[i]; //点集合P1}for (i = mid + 1; (i <= high) && ((s[i].x - s[mid].x) < d); i++){P[index++] = s[i]; //点集合P2}sort(P, P + index, comp_y); //升序排列for (i = 0; i < index; i++){for (j = i + 1; j < index; j++){if ((P[j].y - P[i].y) >= d)break;else{d3 = Distance(P[i], P[j]);if (d3 < d){rec[0].x = P[i].x; rec[0].y = P[i].y;rec[1].x = P[j].x; rec[1].y = P[j].y;d = d3;}}}}delete []P; //注意动态内存的删除⽅式，防⽌内存泄漏return d;}（2）主函数部分：//2018_02_24//使⽤分治法求解⼆维平⾯最接近点问题//============================================================= #include <iostream>#include <math.h>#include <algorithm>#include "dataset.h"//数据结构实现放在这个头⽂件中#include "func.h"//函数声明的头⽂件using namespace std;int main(void){point p[10]; //设定点的集合int n;double minDist;cout << "输⼊点的个数：\n";cin >> n;cout << "输⼊点集：(x , y) \n";for (int i = 0; i < n; i++)cin >> p[i].x >> p[i].y;sort(p, p + n, comp_x); //对输⼊的点先进⾏排序point index[2];minDist = closest_distance(p, 0, n - 1, index);cout << "最⼩距离点对为：(" << index[0].x << "," << index[0].y << "),(" << index[1].x << "," << index[1].y << ")"; cout << "最⼩距离为：\n" << minDist;system("pause");return0;}最后，结果如下：。
分治法二（平面最近点对）
分治法⼆（平⾯最近点对）上篇⽂章介绍了分治法的概念和基本解题步骤，并附加了⼀个例题帮助⼤家了解分治法的基本思想，在这篇⽂章中，我将对分治法的另⼀个经典问题进⾏分析，希望我的⽂章能够将今天的主题解释清楚。
接下来我将⽤三种不同的⽅法求解“平⾯最近点对”问题。
问题描述：在⼀个平⾯上随机分布着 n 个点，现给定 n 个点的坐标，要求给出最近的两个点之间的距离。
⽅法⼀：原始⽅法题⽬要求求出最近的两点之间的距离，先整理⼀下已知的线索：⾸先点的总个数为 n ；其次已知 n 个点的坐标。
掌握了每个点的坐标，就相当于间接地掌握了任意两点之间的距离。
假设两个点为 A : ( x1 , y1 ) , B : ( x2 , y2 ) ,两点间的距离为 distance ，根据平⾯坐标系中的两点间距离公式可得：distance ^ 2 ＝ ( x1 - x2 ) ^ 2 + ( y1 - y2 ) ^ 2，运⽤该公式对每两个点的距离进⾏计算，并不断更新最⼩值 min_distance 。
核⼼代码为：这个⽅法很直观也最容易想到，不过，由以上的两层循环可知，该⽅法的时间复杂度为 o （ n ^ 2 ) ，当 n 的值不断增⼤时，这个⽅法处理起来就显得⼒不从⼼了。
因此我们必须寻找另⼀种更有效的⽅法，或者在此⽅法上进⾏适当的改进。
接下来⼀起了解⼀下第⼆种⽅法－－分治法⽅法⼆：分治法为了做到有理有据，正式叙述解法之前，我得再啰嗦⼏句选择分治法的原因，希望不会引起⼤家的反感。
在本问题中，需要求得最近两点之间的距离，整个问题的规模为 n 个点，不妨将这 n 个点⼀分为⼆，就变成两个求解 n ／2 个点规模下最近点对的距离问题，如此不断缩⼩规模，当变成两个点的规模下求解最近点对问题时，显⽽易见，即为这两个点的距离，这样随着问题规模的缩⼩解决的难易程度逐渐降低的特征正是可以⽤分治法解答的问题所具备的特征。
接下来，我们按照分治法解题步骤分割－－求解－－合并分析这个问题。
用分治法解决最近点对问题：python实现
⽤分治法解决最近点对问题：python实现 最近点对问题:给定平⾯上n个点，找其中的⼀对点，使得在n个点的所有点对中，该点对的距离最⼩。
需要说明的是理论上最近点对并不⽌⼀对，但是⽆论是寻找全部还是仅寻找其中之⼀，其原理没有区别，仅需略作改造即可。
本⽂提供的算法仅寻找其中⼀对。
解决最近点对问题最简单的⽅法就是穷举法，这样时间复杂度是平⽅级，可以说是最坏的策略。
如果使⽤分治法，其时间复杂度就是线性对数级，这样⼤⼤提⾼了效率。
⾸先⽤分治法解决该问题的基本思路可以参考 /lishuhuakai/article/details/9133961 ，说的很详细，但⼤致思路就是先根据x轴把所有点平分，然后分别在每⼀部分寻找最近点对，最后通过⽐较选⼀个最⼩的。
当然其中最核⼼的地⽅是跨域求距离，原⽂写的很清楚，在此就不再赘述了。
以下是代码：from math import sqrtdef nearest_dot(s):len = s.__len__()left = s[0:len/2]right = s[len/2:]mid_x = (left[-1][0]+right[0][0])/2.0if left.__len__() > 2: lmin = nearest_dot(left) #左侧部分最近点对else: lmin = leftif right.__len__() > 2: rmin = nearest_dot(right) #右侧部分最近点对else: rmin = rightif lmin.__len__() >1: dis_l = get_distance(lmin)else: dis_l = float("inf")if rmin.__len__() >1: dis_2 = get_distance(rmin)else: dis_2 = float("inf")d = min(dis_l, dis_2) #最近点对距离mid_min=[]for i in left:if mid_x-i[0]<=d : #如果左侧部分与中间线的距离<=dfor j in right:if abs(i[0]-j[0])<=d and abs(i[1]-j[1])<=d: #如果右侧部分点在i点的(d,2d)之间if get_distance((i,j))<=d: mid_min.append([i,j]) #ij两点的间距若⼩于d则加⼊队列if mid_min:dic=[]for i in mid_min:dic.append({get_distance(i):i})dic.sort(key=lambda x: x.keys())return (dic[0].values())[0]elif dis_l>dis_2:return rminelse:return lmin# 求点对的距离def get_distance(min):return sqrt((min[0][0]-min[1][0])**2 + (min[0][1]-min[1][1])**2)def divide_conquer(s):s.sort(cmp = lambda x,y : cmp(x[0], y[0])) nearest_dots = nearest_dot(s)print nearest_dots测试⼀下，⽐如说要找这些点中最近的⼀对s=[(0,1),(3,2),(4,3),(5,1),(1,2),(2,1),(6,2),(7,2),(8,3),(4,5),(9,0),(6,4)]运⾏⼀下divide_conquer(s)，最终打印出[(6, 2), (7, 2)]，Bingo。
平面最近点对问题（分治）
平⾯最近点对问题（分治）平⾯最近点对问题是指：在给出的同⼀个平⾯内的所有点的坐标，然后找出这些点中最近的两个点的距离.⽅法1：穷举1）算法描述：已知集合S中有n个点，⼀共可以组成n(n-1)/2对点对，蛮⼒法就是对这n(n-1)/2对点对逐对进⾏距离计算，通过循环求得点集中的最近点对2）算法时间复杂度：算法⼀共要执⾏ n(n-1)/2次循环，因此算法复杂度为O(n2)代码实现：利⽤两个for循环可实现所有点的配对,每次配对算出距离然后更新最短距离.for (i=0 ; i < n ;i ++)｛for(j= i+1 ; j<n ;j ++)｛点i与点j的配对｝｝⽅法2：分治1) 把它分成两个或多个更⼩的问题；2) 分别解决每个⼩问题；3) 把各⼩问题的解答组合起来，即可得到原问题的解答。
⼩问题通常与原问题相似，可以递归地使⽤分⽽治之策略来解决。
在这⾥介绍⼀种时间复杂度为O(nlognlogn)的算法。
其实，这⾥⽤到了分治的思想。
将所给平⾯上n个点的集合S分成两个⼦集S1和S2，每个⼦集中约有n/2个点。
然后在每个⼦集中递归地求最接近的点对。
在这⾥，⼀个关键的问题是如何实现分治法中的合并步骤，即由S1和S2的最接近点对，如何求得原集合S中的最接近点对。
如果这两个点分别在S1和S2中，问题就变得复杂了。
为了使问题变得简单，⾸先考虑⼀维的情形。
此时，S中的n个点退化为x轴上的n个实数x1，x2，...，xn。
最接近点对即为这n个实数中相差最⼩的两个实数。
显然可以先将点排好序，然后线性扫描就可以了。
但我们为了便于推⼴到⼆维的情形，尝试⽤分治法解决这个问题。
假设我们⽤m点将S分为S1和S2两个集合，这样⼀来，对于所有的p(S1中的点)和q(S2中的点)，有p<q。
递归地在S1和S2上找出其最接近点对{p1,p2}和{q1,q2}，并设 d = min{ |p1-p2| , |q1-q2| } 由此易知，S中最接近点对或者是{p1,p2}，或者是{q1,q2}，或者是某个{q3,p3}，如下图所⽰。
平面最近点对问题
平⾯最近点对问题平⾯最近点对问题正如其名，给定平⾯上的n个点，找出其中的⼀对点，使得这对点的距离在所有点对中最⼩。
⾸先显⽽易见地我们可以得到这个问题的O(n^2)算法，枚举所有点对即可。
但是很显然我们可以注意到，这⾥⾯有很多点对显然不是最优的，那么我们可以想到⼀种剪枝⽅法，就是将只对x坐标差值⼩于当前已知最⼩值的点对进⾏判断（否则必然不是最优解），从⽽减少判断量。
我们考虑使⽤分治来实现这种剪枝，先将平⾯上的点分为两部分，分治求出两部分内部的最近点对距离。
之后我们要做的就是枚举两个集合之间的点对，并与两部分内部的最近点对距离⽐较来得到最近点对距离。
这⾥我们是不需要枚举所有点对的，因为我们已经得到了⼀个两部分各⾃内部最⼩的点对距离，因⽽我们可以结合上⾯的根据x坐标的剪枝⽅法，只枚举分别属于两部分的x坐标差⼩于已知最⼩距离的点对。
这样做的复杂度近似于O(n\log^2n)，⾄于怎么得到的……我也不知道。
_(:зゝ∠)_例题：1. Vijos 1012 清帝之惑之雍正链接：2. 平⾯最近点对（加强版）链接：另外附上模板：注意，本模板保留六位⼩数，不能直接⽤于提交上⾯的例题，若要提交请修改输出精度。
1 #include <iostream>2 #include <cstdlib>3 #include <cstdio>4 #include <cstring>5 #include <string>6 #include <sstream>7 #include <cctype>8 #include <cmath>9 #include <algorithm>10#define THE_BEST_PONY "Rainbow Dash"1112using namespace std;13const int maxn=220000,INF=~0u>>1;1415struct Point{16double x,y;17bool operator < (const Point &a) const {18if(x<a.x) return true;19if(x>a.x) return false;20return y<a.y;21 }22 }p[maxn];2324int n;25double ans;2627double DisP(int a,int b){28return sqrt((p[a].x-p[b].x)*(p[a].x-p[b].x)+(p[a].y-p[b].y)*(p[a].y-p[b].y));29 }3031double GetAns(int l,int r){32int mid=(l+r)>>1;33if(l==r) return INF;34if(l==r-1) return DisP(l,r);35double len=min(GetAns(l,mid),GetAns(mid+1,r));36for(int i=mid;i>=l;i--){37if(p[i].x+len<p[mid].x) break;38for(int j=mid+1;j<=r;j++){39if(p[mid].x+len<p[j].x) break;40 len=min(len,DisP(i,j));41 }42 }43return len;44 }4546int main(){47 scanf("%d",&n);48for(int i=0;i<n;i++)49 scanf("%lf%lf",&p[i].x,&p[i].y);50 sort(p,p+n);51 ans=GetAns(0,n-1);52 printf("%.6lf",ans);53return0;54 }Processing math: 0%。
用蛮力法和分治法解决最近对问题
算法分析与复杂型设计作业学院计算机与控制工程学院专业计算机软件与理论班级 Y130701 学生姓名郑晓璐流水号 201307892014年4月问题：设p1=(x1, y1), p2=(x2, y2), …, pn=(xn, yn)是平面上n个点构成的集合S，设计算法找出集合S中距离最近的点对。
蛮力算法描述：int ClosestPoints(int n, int x[ ], int y[ ]){minDist=Double.POSITIVE_INFINITY;;for (i=1; i< n; i++)for (j=i+1; j<=n; j++){d=(x[i]-x[j])* (x[i]-x[j])+(y[i]-y[j])* (y[i]-y[j]);if (d< minDist) {minDist=d;index1=i;index2=j;}}return minDist;}程序：import java.util.*;public class ClosestPair1{public static void main(String[] args){/***输入需要比较的点的对数存在变量n中*/Scanner in=new Scanner(System.in);System.out.println("How many pairs of points to compare?(有多少对点需要比较?)");int n=in.nextInt();int[] x=new int[n];int[] y=new int[n];/***输入这些点的横坐标和纵坐标分别存储在x[n]和y[n]*/System.out.println("Please enter these points,X-coordinate(请输入这些点,横坐标):");for(int i=0;i< n;i++){x[i]=in.nextInt();}System.out.println("Please enter these points,Y-coordinate(请输入这些点,纵坐标):");for(int i=0;i< n;i++){y[i]=in.nextInt();}double minDist=Double.POSITIVE_INFINITY;double d;int indexI=0;int indexJ=0;/***求解最近对距离存于minDist中*/double startTime=System.currentTimeMillis();//startTimefor(int i=0;i< n-1;i++){for(int j=i+1;j< n;j++){d=Math.sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]));if(d< minDist){minDist=d;indexI=i;indexJ=j;}}}double endTime=System.currentTimeMillis();//endTime/***打印输出最后求出的结果，最近的是哪两个点，以及最近距离和程序用的时间*/System.out.println("The closest pair is:("+x[indexI]+","+y[indexI]+") and ("+x[indexJ]+","+y[indexJ]+")");System.out.println("The closest distance is "+minDist);System.out.println("Basic Statements take(基本语句用时)"+(endTime-startTime)+" milliseconds!");}}运行：分治算法描述：可以划一条垂线，把点集分成两半：PL和PR。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一. 用分治算法解平面最接近点对问题1.题目关于最接近点对问题:给定平面上n个点，找出其中一对点，使得在n个点所构成的所有点对中，该点对的距离最小。
2.程序详细介绍(各模块的功能等)本程序主要包括两个类:类Point和类Ppoint.其中类Point为处理一些的基本数据传递等.类Ppoint为该程序的主要实现模块,该类中有输入点对的函数shuru,对所输入的点对按X轴排序的函数sort,求各点对的距离的函数xiao等.假设S中的点为平面上的点，它们都有2个坐标值x和y。
为了将平面上点集S线性分割为大小大致相等的2个子集S1和S2，我们选取一垂直线l（方程：x=m）来作为分割直线。
其中m为S中各点x坐标的中位数。
由此将S分割为S1={p∈S|px≤m}和S2={p∈S|px>m}。
从而使S1和S2分别位于直线l的左侧和右侧，且S=S1∪S2 。
由于m是S中各点x坐标值的中位数，因此S1和S2中的点数大致相等。
递归地在S1和S2上解最接近点对问题，我们分别得到S1和S2中的最小距离δ1和δ2.此即为该程序的大致算法.3. 程序结构（流程图）该程序的流程图如下所示4. 调试与测试：调试方法，测试结果（包括输入数据和输出结果）的分析与讨论运行该程序时,屏幕上会出现一个界面,首先该界面会提示输入要处理的点对个数,输入点对个数后从键盘输入数字0即可显示出处理后的各个结果,会出现如下结果:5.程序代码(源程序)#include<iostream>#include<cmath>#include<fstream>using namespace std;int i,j,k,d,m,n;double p2,q,s,r,t;class Point //创建一个点类//{public:double x;double y;double getx(){return x;}double gety(){return y;}friend class Ppoint;};class Ppoint{int sum;double juli[10][10];double min[11]; //min[10]用来存放每组中最短的距离//double mini[11]; //mini[10]用来存放每组中距离最短的点对中的第一个点//double minj[11]; //minj[10]用来存放每组中距离最短的点对中的第二个点//Point p[100];Point p1;public:void shuru(){cout<<"请输入要处理的点的个数"<<endl;cin>>sum;for(i=0;i<sum;i++){cout<<"请输入点对"<<endl;cin>>p[i].x;cin>>p[i].y;cout<<p[i].x<<","<<p[i].y<<endl;}}void sort(){cout<<"以下是按x轴上由小到大排序后的点对"<<endl;for(i=0;i<sum-1;i++){for(j=i+1;j<sum;j++){if(p[i].x>p[j].x){p1=p[i];p[i]=p[j];p[j]=p1;}}}for(i=0;i<sum;i++){cout<<p[i].x<<","<<p[i].y<<endl;}}void xiao(){cout<<"以下是对每个模块中的点求距离"<<endl;for(k=0;k<sum/10;k++){cout<<"按任意键继续"<<endl;cin>>i;cout<<"以下是第"<<k<<"个模块中的距离"<<endl;for(i=1;i<10;i++){for(j=0;j<i;j++){r=abs(p[k*10+i].x-p[k*10+j].x);t=abs(p[k*10+i].y-p[k*10+j].y);juli[i][j]=sqrt(r*r+t*t);cout<<juli[i][j]<<"\t";}cout<<endl;}min[k]=juli[k][0],mini[k]=10*k+1,minj[k]=10*k;for(i=1;i<10;i++){cout<<"\n"<<"第"<<i<<"行以前的最小值为"<<min[k]<<endl;for(j=0;j<i;j++){if(juli[i][j]<min[k]){min[k]=juli[i][j];mini[k]=10*k+i;minj[k]=10*k+j;}}}cout<<"\n"<<"这是第"<<k<<"个模块中的结果"<<endl;cout<<"\n"<<"距离最小值为"<<min[k]<<endl;cout<<"\n"<<"距离最小值的第一个点为"<<mini[k]<<endl; //cout<<"距离最小值的第一个点为"<<mini[k]<<endl;//}if(sum%10!=0){k=sum/10;cout<<"输入0显示结果"<<endl;cin>>i;for(i=1;i<sum%10;i++){for(j=0;j<i;j++){m=abs(p[k*10+i].x-p[k*10+j].x);n=abs(p[k*10+i].y-p[k*10+j].y);juli[i][j]=sqrt(m*m+n*n);cout<<juli[i][j];cout<<"\t";}cout<<endl;}min[k]=juli[1][0],mini[k]=10*k+1,minj[k]=10*k;for(i=1;i<sum%10;i++){cout<<"\n"<<"第"<<i<<"行以前的最小值为"<<min[k]<<endl;for(j=0;j<i;j++){if(juli[i][j]<min[k]){min[k]=juli[i][j];mini[k]=10*k+i;minj[k]=10*k+j;}}}cout<<"\n"<<"这是第"<<k<<"个模块中的结果"<<endl;cout<<"\n"<<"距离最小值为"<<min[k]<<endl;cout<<"\n"<<"距离最小值的第一个点为"<<mini[k]<<endl; //cout<<"距离最小值的第一个点为"<<mini[k]<<endl;}}void realmin(){cout<<"\n"<<"几个模块中的最小值是："<<min[10]<<endl;for(i=0,min[10]=min[0],mini[10]=mini[0],minj[10]=minj[0];i<=sum/10;i++){if(min[i]<min[10]){min[10]=min[i];mini[10]=mini[i];minj[10]=minj[i];}}}void bianjiemin(){cout<<"\n"<<" 包括边界的最小值是："<<min[10]<<endl;for(i=0;i<sum/10;i++){for(k=9;k>=0;k--)if(p[(i+1)*10].x-p[i*10+k].x<min[10]){for(q=0;q<10;q++)if(p[(i+1)*10+m].x-p[(i+1)*10].x<min[10]){m=abs(p[i*10+k].x-p[(i+1)*10+m].x);n=abs(p[i*10+k].y-p[(i+1)*10+m].y);if(min[10]>sqrt(m*m+n*n)){min[10]=sqrt(m*m+n*n);mini[10]=i*10+k;minj[10]=(i+1)*10+q;}}elsebreak;}elsebreak;}}void shuchu(){i=mini[10];j=minj[10];p2= abs(p[i].x-p[j].x)*abs(p[i].x-p[j].x) ;q= abs(p[i].x-p[j].x)*abs(p[i].x-p[j].x) ;s=sqrt(p2+q);cout<<"\n"<<"最接近点对为"<<"p["<<i<<"]"<<"("<<p[i].x<<","<<p[i].y<<")"<<" "<<"p["<<j<<"]"<<"("<<p[j].x<<","<<p[j].y<<")"<<endl;cout<<"\n"<<"最短距离为"<<min[10];cout<<"\n"<<"最短距离为"<<s;}};int main(){Ppoint x;x.shuru();x.sort();x.xiao();x.realmin();x.bianjiemin();x.shuchu();return 0;}二.设计体会通过这次的课程设计，我对C++程序语言有了更进一步的认识。