最近点对问题 二维-实验报告
二维空间最近点对问题的分治算法伪代码
间的最近距离。
常用的解决方式是分治算法。
以下是分治算法的伪代码表示：假设我们的输入是一组点集，我们将它划分为几个部分，然后在每一部分内应用我们的搜索策略，最后将结果合并以得到整个点的最接近对。
```pythonfunction KPPSearch(points, k)if points is empty or k is 1return (points[0], points[0])else if k is 2return min(minDistance(points[left], points[right]), minDistance(points[right], points[middle]))mid = partition(points)closest = minDistance(points[mid], points[left])if k is 3 or closest is greater than 0return (mid, left)elseleftLeft = minDistance(points[left], points[leftLeft])leftRight = minDistance(points[left], points[leftRight])if leftLeft is greater than 0 and leftRight is greater than 0return (leftLeft, leftRight)elsereturn (left, leftRight)function partition(points)pivot = points[0]left = []middle = []right = []for point in points:if point is less than pivot in Euclidean distance:append(point to left)else:append(point to middle)for point in middle:append(point to right)return pivot, left, middle, right```上述伪代码中的主要步骤包括：分治法的核心步骤`partition`函数用于将数据集分为三部分，并且根据选择的"轴"进行划分；然后在每一个部分内，我们会使用这个方法进行搜索。
最接近点对问题实验报告
最接近点对问题一．实验目的：1.理解算法设计的基本步骤及各步的主要内容、基本要求；2.加深对分治设计方法基本思想的理解，并利用其解决现实生活中的问题；3.通过本次实验初步掌握将算法转化为计算机上机程序的方法。
二．实验内容：1.编写实现算法：给定n对点，在这n对点中找到距离最短的点对。
2.将输出数据存放到另一个文本文件中，包括结果和具体的运行时间。
3.对实验结果进行分析。
三．实验操作：1.最接近点对查找的思想：首先，将所有的点对按照x坐标排序，找到x坐标的中位数，将所有的点对分成三部分，横坐标小于x（S1）、等于x（S2）和大于x（S3）的点对，在求取每部分中的最短距离，利用分治法，一步步地分解为子问题，找到最短距离d。
由于距离最近的两个点可能在不同的区域中，需要进一步判断。
选择S1中的一个点，由于与它相比较的点的距离不可能超过d，故其配对范围为d*2d的矩形，将这个矩形划分为6份2/d*3/d的小矩形，其对角线的长度为5/6d，小于d,故S1中的任意一个点只需和S2中的6个点比较即可，最终确定最短的距离。
2.取中位数：为了减少算法的时间开销，需要将所有的点对进行分组，以中位数为基准，考虑到快速排序的不稳定性，本次排序使用了合并排序。
代码实现：template <class Type>void Merge(Type c[],Type d[],int l,int m,int r){int i = l,j = m + 1,k = l;while((i<=m)&&(j<=r)){if(c[i]<=c[j]) d[k++] = c[i++];else d[k++] = c[j++];}if(i>m) {for(int q=j; q<=r; q++) d[k++] = c[q];}else{for(int q=i; q<=m; q++) d[k++] = c[q];}}template <class Type>void MergeSort(Type a[],Type b[],int left,int right){if(left<right){int i = (left + right)/2;MergeSort(a,b,left,i);MergeSort(a,b,i+1,right);Merge(a,b,left,i,right);//合并到数组aCopy(a,b,left,right);//复制回数组a}}3.数据存入文件:本次对文件的输入没有存入文本文件中，只将输出数据输入到指定的文件夹中，用到了输出流文件。
最近点对问题
最近点对问题I.一维问题：一、问题描述和分析最近点对问题的提法是：给定平面上n个点，找其中的一对点，使得在n个点组成的所有点对中，该点对间的距离最小。
严格的讲，最接近点对可能多于1对，为简单起见，只找其中的1对作为问题的解。
简单的说，只要将每一点与其它n-1个点的距离算出，找出达到最小距离的2点即可。
但这样效率太低，故想到分治法来解决这个问题。
也就是说，将所给的平面上n个点的集合S 分成2个子集S1和S2，每个子集中约有n/2个点。
然后在每个子集中递归的求其最接近的点对。
这里，关键问题是如何实现分治法中的合并步骤，即由S1和S2的最接近点对，如何求得原集合S中的最接近点对。
如果组成S的最接近点对的2个点都在S1中或都在S2中，则问题很容易解决，但如果这2个点分别在S1和S2中，问题就不那么简单了。
下面的基本算法中，将对其作具体分析。
二、基本算法假设用x轴上某个点m将S划分为2个集合S1和S2，使得S1={x∈S|x<=m}；S2={x ∈S|x>m}。
因此，对于所有p∈S1和q∈S2有p<q。
递归的在S1和S2上找出其最接近点对{p1，p2}和{q1，q2}，并设d=min{|p1-p2|,|q1-q2|}。
由此易知，S中的最接近点对或者是{p1，p2}，或者是{q1，q2}，或者是某个{p3，q3}，其中p3∈S1且q3∈S2。
如下图所示：S1 S2p1 p2 p3 q1 q2 q3图1 一维情形的分治法注意到，如果S的最接近点对是{p3，q3}，即|p3-q3|<d，则p3和q3两者与m的距离不超过d，即|p3-m|<d，|q3-m|<d。
也就是说，p3∈(m-d，m],q3∈(m，m+d]。
由于每个长度为d的半闭区间至多包含S1中的一个点，并且m是S1和S2的分割点，因此(m-d，m]中至少包含一个S中的点。
同理，(m，m+d]中也至少包含一个S中的点。
4.6 实验项目——最近对问题
3. 实验要求 （1）分别用蛮力法和离治法求解最近对问题； （2）分析算法的时间性能，设计实验程序验证分析结论。
将一个难以直接解决的大问题，划分成一些规模较小的子问题，以便各个击 破，分而治之。更一般地说，将要求解的原问题划分成k个较小规模的子问题， 对这k个子问题分别求解。如果子问题的规模仍然不够小，则再将每个子问题划 分为k个规模更小的子问题，如此分解下去，直到问题规模足够小，很容易求出 其解为止，再将子问题的解合并为一个更大规模的问题的解，自底向上逐步求出 原问题的解。
例：计算an，应用离治技术得到如下计算方法：
n
a
分析时 间性能
= n a
a 2 ´ a n
34
2
如果 n = 1 如果 n > 1
32 31 3 31 3 31 3
32 31
分解问题 求解每个子问题
3
9 合并子问题的解
9
81
不是所有的离治法都比简单的蛮力法更有效。
在世界刚被创建的时候有一座钻石宝塔（塔 A ） ，其上有64个金碟。所有碟子按从大到小的次序 从塔底堆放至塔顶。紧挨着这座塔有另外两个钻 石宝塔（塔 B 和塔 C ）。从世，其间借助于塔 B 的帮助。每次只能 移动一个碟子，任何时候都不能把一个碟子放在 比它小的碟子上面。当牧师们完成任务时，世界 末日也就到了。
（ 3 ）合并：将这两个有序子序列合并成一个有 序序列。
r1 … … rn/2
rn/2＋1 … … rn
划分 途
r‘1<… …<r’n/2 r’n/2＋1<… …<r’n 归处理 r''1<……<r''n/2<r''n/2＋1 <……<r ''n
最小距离问题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)){ 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=closestPoint(s,low,mid,rec); temp1[0]=rec[0]; temp1[1]=rec[1]; d2=closestPoint(s,mid+1,high,rec); temp2[0]=rec[0]; temp2[1]=rec[1]; if(d1<d2){ d=d1; rec[0]=temp1[0]; rec[1]=temp1[1]; } else { d=d2; rec[0]=temp2[0]; rec[1]=temp2[1]; } index=0; for(i=mid;(i>=low)&&((s[mid].x-s[i].x)<d);i--) P[index++]=s[i]; for(i=mid+1;(i<=high)&&((s[i].x-s[mid].x)<d);i++) P[index++]=s[i]; sort(P,P+index,cmp); for(i=0;i<index;i++){ for(j=j+1;j<index;i++){ if((P[j].y-P[i].y)>=d) break; else { d3=Distance(P[i],P[j]); //升序排列 //点集合 p2 //点集合 p1
最近点对算法
最近点对算法1. 简介最近点对算法（Closest Pair Algorithm）是一种用于找到平面上最近的两个点的算法。
该算法可以在给定一组点的情况下，找到距离最近的两个点，并计算出它们之间的距离。
最近点对问题在计算几何学、图像处理、数据挖掘等领域中具有广泛应用。
例如，在地理信息系统中，可以使用最近点对算法来查找距离最近的两个地理位置；在机器视觉中，可以使用该算法来寻找图像中距离最接近的两个特征点。
2. 算法思想最近点对算法采用分治策略，将问题划分为多个子问题，并通过递归求解子问题来得到整体解。
其基本思想可以概括为以下步骤：1.将所有点按照横坐标进行排序。
2.将排序后的点集平均划分为左右两部分，分别称为P_left和P_right。
3.分别在P_left和P_right中递归求解最近点对。
4.在左右两部分求得的最近点对中，选择距离更小的那一对作为候选解。
5.在区间[P_left[-1].x, P_right[0].x]内，查找可能的更近点对。
6.比较候选解与新找到的更近点对，选择距离更小的那一对作为最终解。
3. 算法实现3.1 数据结构在实现最近点对算法时，需要定义合适的数据结构来表示点。
常见的表示方法是使用二维数组或类对象。
以下是使用类对象来表示点的示例代码：class Point:def __init__(self, x, y):self.x = xself.y = y3.2 算法步骤3.2.1 排序首先，将所有点按照横坐标进行排序。
可以使用快速排序或归并排序等算法来实现排序功能。
def sort_points(points):# 使用快速排序按照横坐标进行排序# ...3.2.2 分治求解将排序后的点集平均划分为左右两部分，并递归求解最近点对。
def closest_pair(points):n = len(points)# 如果点集中只有两个点，则直接返回这两个点和它们之间的距离if n == 2:return points, distance(points[0], points[1])# 如果点集中只有三个点，则直接计算出最近点对if n == 3:d1 = distance(points[0], points[1])d2 = distance(points[0], points[2])d3 = distance(points[1], points[2])if d1 <= d2 and d1 <= d3:return [points[0], points[1]], d1elif d2 <= d1 and d2 <= d3:return [points[0], points[2]], d2else:return [points[1], points[2]], d3# 将点集平均划分为左右两部分mid = n // 2P_left = points[:mid]P_right = points[mid:]# 分别在左右两部分递归求解最近点对closest_pair_left = closest_pair(P_left)closest_pair_right = closest_pair(P_right)# 在左右两部分求得的最近点对中，选择距离更小的那一对作为候选解if closest_pair_left[1] < closest_pair_right[1]:min_pair, min_distance = closest_pair_leftelse:min_pair, min_distance = closest_pair_right3.2.3 查找更近点对在区间[P_left[-1].x, P_right[0].x]内，查找可能的更近点对。
平面最近点对问题（分治）
平⾯最近点对问题（分治）平⾯最近点对问题是指：在给出的同⼀个平⾯内的所有点的坐标，然后找出这些点中最近的两个点的距离.⽅法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}，如下图所⽰。
最接近点对问题
一、最接近点对问题（一维）1、最接近点对问题（一维）最接近点对问题:给定平面上n个点，找其中的一对点，使得在n个点的所有点对中，该点对的距离最小。
此时S中的n个点退化为x轴上的n个实数x1,x2,..,x n。
最接近点对即为这n 个实数中相差最小的2个实数。
2、分析将所给的平面上n个点的集合S分成2个子集S1和S2，每个子集中约有n/2个点，·然后在每个子集中递归地求其最接近的点对。
S1和S2的最接近点对未必就是S的最接近点对，如果组成S的最接近点对的2个点都在S1中或都在S2中，则问题很容易解决。
但是，如果这2个点分别在S1和S2中，则对于S1中任一点p，S2中最多只有n/2个点与它构成最接近点对的候选者，仍需做n2/4次计算和比较才能确定S的最接近点对。
因此，依此思路，合并步骤耗时为O(n2)。
整个算法所需计算时间T(n)应满足:T(n)=2T(n/2)+O(n2)它的解为T(n)=O(n2)3、伪代码随机Randomfloat Random(){float result=rand()%10000;return result*0.01;}返回最大、最小float Max OR Min(float s[],int p,int q)//返回s[]中的最大值{float s_max（s_min）=s[p];for(int i=p+1;i<=q;i++)if(s_max<s[i])s_max=s[i]; ORif(s_min>s[i])s_min=s[i];return s_max（s_min）}主要函数Cpair Cpair1(float s[],int n){Cpair out_p_d={99999,0,0};if(n<2) return out_p_d;float m1=Max(s,0,n-1),m2=Min(s,0,n-1);float m=(m1+m2)/2;//找出点集中的中位数int j=0,k=0;//将点集中的各元素按与m的大小关系分组float s1[M],s2[M];for(int i=0;i<n;i++){if(s[i]<=m) {s1[j]=s[i];j++;}else {s2[k]=s[i];k++;}}Cpair d1=Cpair1(s1,j),d2=Cpair1(s2,k);//递归float p=Max(s1,0,j-1),q=Min(s2,0,k-1);//返回s[]中的具有最近距离的点对及其距离if(d1.d<d2.d){if((q-p)<d1.d){out_p_d.d=(q-p);out_p_d.d1=q;out_p_d.d2=p;return out_p_d;}else return d1;}else{if((q-p)<d2.d){out_p_d.d=(q-p);out_p_d.d1=q;out_p_d.d2=p;return out_p_d;}else return d2;}}4、程序实现#include<time.h>#include <iostream>using namespace std;const int M=50;struct Cpair{float d;float d1,d2;};float Random();int input(float s[],int number_used);float Max(float s[],int p,int q);float Min(float s[],int p,int q);Cpair Cpair1(float s[],int n);void main(){srand((unsigned)time(NULL));int number_used,m;float s[M];Cpair d;m=input(s,number_used);d=Cpair1(s,m);cout<<endl<<"the closest pair is ("<<d.d1<<","<<d.d2<<")";cout<<endl<<"the min distance is "<<d.d<<endl;}float Random(){float result=rand()%10000;return result*0.01;}int input(float s[],int number_used){cout<<"input the number ";cin>>number_used;cout<<"the random number are ";for(int i=1;i<=number_used;i++){s[i]=Random();cout<<s[i]<<" ";}return number_used;}float Max(float s[],int p,int q)//返回s[]中的最大值{float s_max=s[p];for(int i=p+1;i<=q;i++)if(s_max<s[i])s_max=s[i];return s_max;}float Min(float s[],int p,int q)//返回s[]中的最小值{float s_min=s[p];for(int i=p+1;i<=q;i++)if(s_min>s[i])s_min=s[i];return s_min;}//返回s[]中的具有最近距离的点对及其距离Cpair Cpair1(float s[],int n){Cpair out_p_d={99999,0,0};if(n<2) return out_p_d;float m1=Max(s,0,n-1),m2=Min(s,0,n-1);float m=(m1+m2)/2;//找出点集中的中位数int j=0,k=0;//将点集中的各元素按与m的大小关系分组float s1[M],s2[M];for(int i=0;i<n;i++){if(s[i]<=m) {s1[j]=s[i];j++;}else {s2[k]=s[i];k++;}}Cpair d1=Cpair1(s1,j),d2=Cpair1(s2,k);//递归float p=Max(s1,0,j-1),q=Min(s2,0,k-1);//返回s[]中的具有最近距离的点对及其距离if(d1.d<d2.d){if((q-p)<d1.d){out_p_d.d=(q-p);out_p_d.d1=q;out_p_d.d2=p;return out_p_d;}else return d1;}{if((q-p)<d2.d){out_p_d.d=(q-p);out_p_d.d1=q;out_p_d.d2=p;return out_p_d;}else return d2;}}运行情况：二、最接近点对问题（二维）1、最接近点对问题（二维）二维时S中的点为平面上的点，它们都有2个坐标值x和y。
平面最近点对问题
平⾯最近点对问题平⾯最近点对问题正如其名，给定平⾯上的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%。
求两组点之间的最近点对实验总结
求两组点之间的最近点对实验总结在计算几何学和算法设计中，求两组点之间的最近点对是一个重要且常见的问题。
在这篇文章中，我将从简到繁地探讨这个主题，深入分析求解最近点对的算法，并进行实验总结，以便读者能更深入地理解这一概念。
一、什么是最近点对问题？最近点对问题是指在一个平面上给定n个点，要求在这些点中找到距离最近的两个点。
这个问题在实际中有着广泛的应用，比如计算机视觉中的物体识别、无人驾驶车辆的障碍物检测等都涉及到最近点对的计算。
设计高效的算法来解决最近点对问题具有重要意义。
二、最近点对的暴力解法最简单的方法是通过遍历所有点对，计算它们之间的距离，并找到最小值。
这种暴力解法的时间复杂度为O(n^2)，空间复杂度为O(1)，虽然简单易懂，但对于大规模的数据集来说效率较低。
三、分治法解决最近点对问题分治法是解决最近点对问题的常见方法，其基本思想是将点集分成两个子集，分别求解最近点对，然后再找出整个点集的最近点对。
在这个过程中需要用到分治、筛选和合并三个步骤。
具体算法流程如下：1. 将点集按照x坐标排序，找到中间线将点集分成左右两个子集。
2. 递归求解左右子集的最近点对。
3. 筛选出距离中线距离小于当前最近距离的点，将它们按照y坐标排序。
4. 在筛选后的点集中，以每个点为中心，向上下各取6个点。
5. 计算这些点之间的距离，更新最近距离。
6. 合并左右子集的结果，得到最终的最近点对。
使用分治法解决最近点对问题的时间复杂度为O(nlogn)，效率较高，适用于大规模数据集。
四、实验总结及个人观点在进行最近点对的实验过程中，我发现分治法在处理大规模数据集时具有明显的优势，其算法设计合理、程序实现简单高效。
对于中等规模的数据集，暴力解法也能够得到较好的结果，但对于大规模数据集来说效率明显低于分治法。
我个人认为在解决最近点对问题时，应优先考虑使用分治法，并且可以根据数据规模选择不同的算法来达到更高的效率。
总结来说，求两组点之间的最近点对是一个重要且常见的问题，在实际应用中具有广泛的意义。
算法分析与复杂性理论-实验报告-求最近点对的问题
深圳大学实验报告教务部制1.对于平面上给定的N个点，给出所有点对的最短距离，即，输入是平面上的N个点，输出是N点中具有最短距离的两点。
2.要求随机生成N个点的平面坐标，应用蛮力法编程计算出所有点对的最短距离。
3.要求随机生成N个点的平面坐标，应用分治法编程计算出所有点对的最短距离。
4.分别对N=100,1000,10000,100000 ,统计算法运行时间，比较理论效率与实测效率的差异，同时对蛮力法和分治法的算法效率进行分析和比较。
5.利用Unity3D输出分治算法中间每个步骤的计算结果，并增设help按钮，详细解释算法思想。
算法思想提示1.预处理：根据输入点集S中的x轴和y轴坐标进行排序，得到X和Y,很显然此时X和Y 中的点就是S中的点。
2.点数较少时的情形直接计菊只有三个疽3.点数|S|>3时，将平面点集S分割成为大小大致相等的两个子集S L和S R,选取一个垂直线L作为分割直线，考虑X L和X R,Y L和Y R,这里还需要排序吗？4.两个递归调用，分别求出S L和S R中的最短距离为d i和d r。
5.取d=min(dl, dr)，在直线L两边分别扩展d,得到边界区域Y, Y'是区域Y中的点按照y坐标值排序后得到的点集，Y'又可分为左右两个集合Y 'L和Y 'RL.一L<dL+d6.对于Y'L中的每一点，检查Y'R中的点与它的距离，更新所获得的最近距离实验过程及内容：(实验代码已作为附件提交，名为“算法实验二.cpp)当点的数量小丁3时，直接计算，当点的个数大丁3时，采用分治法当N=1时当N=2时只有两个点，最近点对就是这两个点测试数据为(1,1 ) (2,2)预期结果为d=1.414使用蛮力法求最近点对，核心代码如下〃求距离平方的函数double Distinyuish2(Node a t Node b)return ((d.x-b.x)*(a.x-b.x)) + ((a.y-tj.y)*(a.y-b.y));〃蛮力法求最近对uoid BriiteForce(const HList & L,CloseHode & cnode,int begin v int end)For(int i=t)egin;i<=end;i*+)Forfinit j<-end;j + + )double space = Di stinguish2(L.data[i],L.data[j]); iF<sp^ce<cnode.5pact)cnode_a=L.data[l]; cnade.b=L.data[j]; cnode .space=space;（计算两点之间的距离，分别将每个点与其它点的距离求出来，找出最近点距离）当N>3时，使用分治法的情况核心代码如下:；15E 〃当n》3时进行分治<APOIHT *SL-nev fi_POINT[(high-low)/2+1];■[POINT *SR-nev A>0IHT[ (hi^i-low)/2];n)= (high-low)/2; /成曦(组以缺)界划分为茜半j=k=t);for(i=B;i<=high-lou;i*+)if(V[i]*indeK<=n){SL[ ji ] T [i]；〃收集左边子集中的最近点对pise{SR[kt+]=Y[i];〃收集右边子集中的最近点对>)closest (K.SL,low,■,al,bl,dl);//i+ 算左边子集的最近点对closes t (X,Sft,m+1,tiigh,ar.br,dr 算右边子靠的最近点对if(dl<dr);b=bl;d=dl;}else(a=ar;b=tjr ；d=dr;POIlfT *2=new POI NT[higti-low+1 ];k=o；For(i=B;i<=t*igh-lcw;i*+)//收集距离中线?寤小于U的元素，保存S懒组?中(iF(f=abstX[n] .x-V[l] .x)<d>2(k].x=V[i],x;£[k^+].y=V[i]^：for(i-l;l<k;l++)< far(j=i>1;(-y-Z[i] j++)dl=aist(Z[i]^[j]);{a = 2[iJ；b - Z[j];ri = d) ■当N=6时，给定一组测试数据下面随机生成N个点的平面坐标，求解最近点对。
【精品】最近点对问题
【精品】最近点对问题点对问题是计算机科学中常见的算法问题，也称为最近点对问题。
其目标是在给定一组点的集合中找到最近的两个点。
在这个问题中，我们将使用分治法来解决最近点对问题。
算法的基本思想是将点集按照x坐标进行排序，并将其分成两个子集。
然后，我们对每个子集递归地应用算法，直到子集中只有一个或两个点。
在这种情况下，我们可以直接计算出最近的点对。
然而，当子集中有超过两个点时，我们需要将问题分解成更小的子问题。
我们选择一个中间点，将点集分成两个子集，并计算出每个子集中的最近点对。
然后，我们需要考虑横跨两个子集的点对。
我们使用一个辅助函数来计算两个子集中的最近点对，并返回最小距离。
在计算最近点对时，我们需要考虑两个子问题。
首先，我们需要找到两个子集中的最近点对。
其次，我们需要找到横跨两个子集的最近点对。
为了找到两个子集中的最近点对，我们可以使用递归地应用相同的算法。
我们将两个子集分别按照y坐标进行排序，并计算出每个子集中的最近点对。
然后，我们需要考虑两个子集之间的点对。
我们将点集中的点按照y坐标进行排序，并找到一个以中间点为中心，距离中间点小于最小距离的点集。
然后，我们可以使用一个循环来比较这些点对，并计算出最小距离。
在计算横跨两个子集的最近点对时，我们需要考虑两个子集之间的点对。
我们将点集中的点按照y坐标进行排序，并找到一个以中间点为中心，距离中间点小于最小距离的点集。
然后，我们可以使用一个循环来比较这些点对，并计算出最小距离。
最后，我们将上述步骤的结果与之前计算的最小距离进行比较，选择较小的距离作为最终的最近点对。
分治法是解决最近点对问题的一个有效方法。
它通过将问题分解成更小的子问题，然后递归地解决这些子问题，最终得到整个问题的解。
在最近点对问题中，我们通过将点集按照x坐标和y坐标进行排序，并使用分治法找到最近点对。
通过使用分治法，我们可以在O(nlogn)的时间复杂度内解决最近点对问题。
这使得它成为处理大规模数据集的理想选择。
最近对问题
《算法设计与分析》实验报告二学号：姓名：日期：得分：一、实验内容:使用递归算法求解平面上n个点组成的集合中的最近点对。
二、所用算法的基本思想及复杂度分析：使用分治法解决最近点对问题就是将集合S分成两个子集是S1和S2,每个子集中有N/2个点。
然后再每个子集中递归的求其最接近的点对，求出每个子集的最接近点对后，如果集合S中最接近的点对都在两个子集中，问题解决。
当两个点分别在两个子集中时，则最近点对为S1和S2的最接近点。
其时间复杂度为O(nlogn)三、源程序及注释：#include<iostream>#include<algorithm>#include<cmath>using namespace std;struct Point{double x;double y;};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 cmp_x(Point a,Point b)//比较两点的x坐标{return b.x>a.x;}double ClosestPoints(Point P[],int n,Point &a,Point &b)//n是输入点的个数 a，b表示最近点对，d记录最小距离{double d1,d2,m;//d1为p1的最近距离，dr是p2的最近距离，m表示最近点对在p1,p2时的最近距离int i=0,l=0,r=0,k=0,j=0;Point a1,b1,a2,b2;int center=n/2;double d;if(n<2)return 9999999;if(n==2)//只有两个点的时候{d=distance(P[0],P[1]);a=P[0];b=P[1];}else //当n>2时，采用递归{Point *p1=new Point[n]; //p1是左边的子集，p2是右边的子集Point *p2=new Point[n];sort(P,P+n,cmp_x); //对集合中的点按照x坐标大小排序double m=P[(n-1)/2].x; //x坐标的中位点for(i=0;i<center;i++) //构造p1和p2,使得p1中点的x坐标小于m，s2中点的x坐标大于mp1[l++]=P[i];for(i=center;i<n;i++)p2[r++]=P[i];d1=ClosestPoints(p1,l,a1,b1);//使用递归求s1,s2中的最近点对d2=ClosestPoints(p2,r,a2,b2);if(d1<d2){d=d1;a=a1;b=b1;}else{d=d1;a=a2;b=b2;}Point *p3=new Point[n]; //最近的两个点在两个子集中for(i=0;i<=n;i++){if(abs(P[i].x-middle)<d) //将p[]距离小于d的点放到p3中{p3[k].x=P[i].x;p3[k++].y=P[i].y;}}for(i=0;i<k ;i++) //对p1中的点p，在p2中查找与点p的y坐标距离小于d的点，并求出最小值；{for(j=i+1;(j<k)&&(abs(p3[i].y-p3[j].y)<d);j++){m=distance(p3[i],p3[j]);if(m<d){d=m;a=p3[i];b=p3[j];}}}}return d;}void main(){int n;Point a,b;double d;printf("输入点的个数:");scanf("%d",&n);Point *point=new Point[n];printf("输入点集:");for(int i=0;i<n;i++){scanf("%lf%lf",&point[i].x,&point[i].y);}d=ClosestPoints(point n,a,b);printf("最近点对是:(%.2lf,%.2lf),(%.2lf,%.2lf)",a.x,a.y,b.x,b.y);printf("\n最近距离:%lf\n",d);}四、运行输出结果：五、调试和运行程序过程中产生的问题、采取的措施及获得的相关经验教训：1、在对点集中的数据按照x的坐标排序时，一开始使用快速排序，代码较长复杂，然后经查询使用了sort和cmp函数，简便了排序过程。
二维面的作业实验报告感悟
二维面的作业实验报告感悟摘要：本实验报告旨在总结和分享关于二维面作业实验的经验和感悟。
通过对二维平面的研究和实践，我深刻认识到二维平面的重要性和应用价值，同时也提升了自己的设计能力和创造力。
本文将分享我在实验中的学习过程、实验结果和心得体会。
引言：二维平面在日常生活中随处可见，例如海报、画作、网页设计等。
通过本次实验，我希望能够更好地理解和掌握二维平面的设计原理和技巧，从而提升我的设计能力。
实验过程：在实验中，我首先学习了二维平面的基本概念和构造原理，包括线条、形状、颜色等元素的运用。
然后，我通过实践运用这些元素创建了几个二维平面作品，例如抽象画、海报设计等。
在创作过程中，我尝试了不同的设计风格和表达方式，以提升作品的视觉效果和艺术感染力。
实验结果：通过实验，我成功地创建了几个具有独特风格和个人特色的二维平面作品。
这些作品结合了线条、形状和颜色的运用，呈现出丰富的视觉效果和艺术表达。
在展示我的作品时，我收到了同学和老师的积极反馈，这进一步鼓舞了我继续深入学习和探索二维平面设计领域的动力。
心得体会：通过本次实验，我深刻认识到二维平面设计的重要性和魅力。
二维平面作品不仅可以传达信息和表达情感，还可以激发观众的联想和思考。
在实验中，我学会了如何运用线条、形状和颜色等元素来创造出令人印象深刻的作品。
同时，我也明白了设计的过程需要不断的尝试和实践，只有通过反复的实验和改进，才能不断提升自己的设计水平。
结论：通过本次实验，我对二维平面设计有了更深入的理解和掌握。
我相信，通过不断的学习和实践，我将能够在二维平面设计领域取得更大的进步，并为创造出优秀的作品做出更多贡献。
二维空间求最近点对算法模板
二维空间求最近点对算法模板（分治法）选取一垂直线l:x=m来作为分割直线。
其中m为S中各点x坐标的中位数。
由此将S分割为S1和S2。
递归地在S1和S2上找出其最小距离d1和d2，并设d=min{d1,d2}，S中的最接近点对或者是d，或者是某个{p,q}，其中p∈P1且q∈P2 ，如图所示。
能否在线性时间内找到p,q？考虑P1中任意一点p，它若与P2中的点q构成最接近点对的候选者，则必有distance(p，q)＜d。
满足这个条件的P2中的点一定落在一个d×2d的矩形R 中，如图所示。
由d的意义可知，P2中任何2个S中的点的距离都不小于d。
由此可以推出矩形R中最多只有6个S中的点。
证明：将矩形R的长为2d的边3等分，将它的长为d的边2等分，由此导出6个(d/2)×(2d/3)的矩形（如图(a)所示）。
若矩形R中有多于6个S中的点，则由鸽舍原理易知至少有一个(d/2)×(2d/3)的小矩形中有2个以上S中的点。
设u，v是位于同一小矩形中的2 个点，则因此，distance(u,v)<d。
这与d的意义相矛盾。
也就是说，矩形R中最多有6个S中的点。
极端情形：图(b)是矩形R中恰有6个S中的点的极端情形。
因此，在分治法的合并步骤中最多只需要检查6×n/2=3n个候选者。
为了确切地知道要检查哪6个点，可以将p和P2中所有S2的点投影到垂直线l 上。
由于能与p点一起构成最接近点对候选者的S2中点一定在矩形R中，所以它们在直线l上的投影点距p在l上投影点的距离小于d。
由上面的分析可知，这种投影点最多只有6个。
因此，若将P1和P2中所有S中点按其y坐标排好序，则对P1中所有点，对排好序的点列作一次扫描，就可以找出所有最接近点对的候选者。
对P1中每一点最多只要检查P2中排好序的相继6个点。
算法描述：public static double CPair2(S){n=|S|;if (n < ; 2) returnm=S中各点x间坐标的中位数;构造S1和S2；//S1={p∈S|x(p)<=m},S2={p∈S|x(p)>m}d1=cpair2(S1);d2=cpair2(S2);dm=min(d1,d2);设P1是S1中距垂直分割线l的距离在dm之内的所有点组成的集合；模板程序：#include <iostream>#include <algorithm>#include <cmath>using namespace std;#define MAXN 100000struct node{ double x,y; }point[MAXN];//存放点的结构体数组bool cal_less(node p1,node p2){ if(p1.x != p2.x) return p1.x < p2.x; else return p1.y < p2.y; }double dist(node a, node b){ return sqrt((a.x - b.x)*(a.x - b.x) + (a.y - b.y)*(a.y - b.y)); }double getmin(double a, double b){ return a<b?a:b; }double solve(int l,int r){ if(l == r) return 1000000000;if(l == r - 1) return dist(point[l],point[r]);if(l == r - 2) returngetmin(getmin(dist(point[l],point[l+1]),dist(point[l+1],point[l+2])),dist(point[l],point[l+2]));int i,j,mid = (l+r) >> 1;double curmin = getmin(solve(l,mid),solve(mid+1,r));for(i=l;i<=r;i++)for(j=i+1;j<=i+5 && j<=r;j++){ curmin = getmin(curmin,dist(point[i],point[j])); }return curmin;}//入口函数，n代表点的个数double ClosestPairDistance(int n){ sort(point,point+n,cal_less);return solve(0,n-1);}。
最近点对问题
算法分析与设计最近对问题最近对问题问题描述：在二维平面上的n 个点中，如何快速的找出最近的一对点，就是最近点对问题。
程序设计思想：1.蛮力法求最近对问题：基本思想：分别计算每一对点之间的距离，然后找出距离最小的那一对，为了避免对同一对点计算两次距离，只考虑j i <的那些点对()j i P P ,。
复杂度分析：对于此算法，主要就是算两个点的欧几里得距离。
注意到在求欧几里得距离时，避免了求平方根操作，其原因是：如果被开方的数越小，则它的平方根也越小。
所以复杂度就是求平方，求执行次数为： )()1()(2n O n n n T =-=;即时间复杂度为)(2n O 。
2.分治法求最近对问题：基本思想：用分治法解决最近点对问题，就是将一个问题分解两个子问题，然后递归处理子问题，然后合并。
可能两个点在每个子问题中，也可能两个点分别在两个子问题中，就这两种情况。
则基本过程为：找一条中垂线m (坐位S 集合x 坐标的中位数)把n 个元素分成左右两部分元素，然后分别求得两边的最短距离1d ,2d ，然后取两者中的最小者记为d ，在中线两边分别取d 的距离，记录该距离范围内点的个数，中线左边有L 个元素，右边有R 个元素，分别将两边的点按y 坐标升序排列，在左边集合中每一个点，找右边集合的点，找到与之距离小于d 的点，更新最短距离，直到循环结束，即可求出最短距离。
复杂度分析：应用分治法求解含有n 个点的最近对问题，其时间复杂性可由递推式表示：)()2/(*2)(n f n T n T +=。
由以上分析：合并子问题的解的时间)1()(O n f =。
进而可得分治法求最近对问题的时间复杂度为：)log ()(2n n O n T =。
程序代码：#include <stdio.h>#include <stdlib.h>#include <math.h>#define NUM 1000typedef struct{int x;int y;}N;double distance(N n1,N n2);double minDis(double d1,double d2);double shortestDis(N *data,int length,N *n1 , N *n2); double shortestDis(N *data,int length,N *n1 , N *n2){ int pre,last,middle,median;int i,c1num = 0,c2num = 0,j;N* dataP;N* dataL;N* CP;N* CL;N tn1,tn2;double dis1 ,dis2;// 当只有两个点时，返回最短距离，和点if(length == 2 ){double dis1 = distance(data[0],data[1]);*n1 = data[0];*n2 = data[1];return dis1;}else if(length == 3){// 当只有三个点时，返回最短距离，和点double dis1 = distance(data[0],data[1]);double dis2 = distance(data[1],data[2]);double dis3 = distance(data[0],data[2]);double temp;temp = dis1 < dis2 ? dis1:dis2;temp = temp < dis3 ? temp : dis3;if(temp == dis1){*n1 = data[0];*n2 = data[1];}else if(temp == dis2){*n1 = data[1];*n2 = data[2];}else{*n1 = data[0];*n2 = data[2];}return temp;}middle =length/2;pre = middle;last = length - pre;median = data[middle].x; // 记录中位数dataP = (N*)malloc(sizeof(N)*pre);dataL = (N*)malloc(sizeof(N)*last);CP = (N*)malloc(sizeof(N)*pre);CL = (N*)malloc(sizeof(N)*last);for( i = 0;i < pre ;i++)dataP[i] = data[i];for( i = 0; i< last;i++)dataL[i] = data[i+pre];dis1 = shortestDis(dataP , pre , n1 , n2);dis2 = shortestDis(dataL , last , &tn1 , &tn2);if(dis1 > dis2){*n1 = tn1;*n2 = tn2;}dis1 = minDis(dis1,dis2);for( i = 0; i < pre ; i++)if(dataP[i].x - median < dis1){CP[c1num++] = dataP[i];} // 将在中位数之前的区域中与中位数距离小于最短距离的点放到CP 中for( i = 0; i < last ; i++)if(median - dataL[i].x < dis1){CL[c2num++] = dataL[i];}// 将在中位数之后的区域中与中位数距离小于最短距离的点放到CL 中for(i = 0; i< c1num;i++){for( j =0; j < c2num ; j++){double temp = distance(CP[i],CL[j]);if(temp < dis1){dis1 = temp;*n1 = CP[i];*n2 = CL[j];}}}//依次计算中位数两旁的区域中，每一个点与另外一个区域中的距离，并且记录最短距离return dis1;}double distance(N n1,N n2){return sqrt((n1.x -n2.x)*(n1.x -n2.x) + (n1.y - n2.y)*(n1.y - n2.y));}double minDis(double d1,double d2){double d = d1 < d2 ? d1 : d2;return d;}// 分治法排序void MergeSort(N q[],int num,int mode){int i,nump,numl;N* qPre;N* qLast;if(num == 1 )return;if(num%2&&num != 2){numl = num/2;nump = num/2;nump++;}else{numl = num/2;nump = num/2;}qPre = (N*)malloc(sizeof(N)*nump);qLast = (N*)malloc(sizeof(N)*numl);for(i = 0;i < nump;i++)qPre[i] = q[i];for(i = 0;i<numl;i++)qLast[i] = q[nump+i];MergeSort(qPre,nump,mode);MergeSort(qLast,numl,mode);Merge(qPre,qLast,q,nump,numl,mode);}void Merge(N *pre,N *last,N *total,int nump,int numl,int mode){ int i = 0,j = 0,k = 0;while( i< nump && j< numl ){if(mode == 0){if(pre[i].x > last[j].x ){total[k++] = pre[i++];}else{total[k++] = last[j++];}}else{if(pre[i].y > last[j].y ){total[k++] = pre[i++];}else{total[k++] = last[j++];}}}if(i == nump){for(i = j; i < numl; i++)total[k++] = last[i];}else{for(j = i; j < nump; j++)total[k++] = pre[j];}}void computeShortestDistance(N* data , int num ,int result[4]){FILE *fo;int i,j,l = 0;int *datax,*datay;double dis = 666666,temp;datax = (int*)malloc(sizeof(int)*1000);datay = (int*)malloc(sizeof(int)*1000);for(i =0; i<num ;i++){datax[i] = data[i].x;datay[i] = data[i].y;}for(i = 0;i<num;i++){for(j = i+1;j<num;j++)if((temp = (datax[i] - datax[j])*(datax[i] - datax[j]) + (datay[i] - datay[j])*(datay[i] - datay[j])) < dis){dis = temp;result[0] = datax[i];result[1] = datay[i];result[2] = datax[j];result[3] = datay[j];}}printf("\n蛮力法:\n");printf("shortest dis: %f",sqrt(dis));}void generateDots(int number){FILE *fo;int i,n1,n2;if(!(fo = fopen("data.txt","w"))){printf("open file fail");exit(1);}for(i = 0;i< number;i++){srand((i*i));n1 =rand()%8000;srand(time(NULL)*i*i);n2 = rand()%6000;if(i%2)fprintf(fo,"%d %d\n",n1,n2);elsefprintf(fo,"%d %d\n",n2,n1);}fclose(fo);}int main(){ FILE* fo;N* data;int i;N n1,n2;double dis;int re[4];// 生成数据generateDots(NUM);data = (N*)malloc(sizeof(N)*1000);if(!(fo = fopen("data.txt","r"))){printf("open file fail");exit(1);}for(i = 0;i < NUM;i++){fscanf(fo,"%d %d",&data[i].x,&data[i].y);}fclose(fo);// 合并排序，排好序的数据放置到data 中。
二维实验总结报告范文(3篇)
第1篇一、实验背景二维材料，作为一种新型材料，近年来在物理学、化学、材料科学等领域引起了广泛关注。
二维材料具有独特的物理和化学性质，如高导电性、高载流子迁移率、低能耗等，使其在电子器件、能源存储、催化等领域具有广泛的应用前景。
本实验旨在通过制备二维材料，研究其物理和化学性质，为二维材料的应用提供理论依据。
二、实验目的1. 学习和掌握二维材料的制备方法；2. 探究二维材料的物理和化学性质；3. 分析二维材料在不同应用领域的潜在价值。
三、实验原理二维材料是指具有单层原子或分子层结构的材料。
本实验主要采用液相剥离法制备二维材料，该方法具有操作简单、成本低廉、易于规模化生产等优点。
实验中，将石墨烯、二硫化钼等二维材料前驱体分散于溶剂中，通过搅拌、超声等手段，使二维材料前驱体在溶剂中形成均匀分散的悬浮液。
然后，通过旋涂、滴涂等方法，将悬浮液涂覆在基底材料上，形成二维材料薄膜。
四、实验材料与仪器1. 实验材料：石墨烯、二硫化钼、溶剂、基底材料等；2. 实验仪器：旋涂机、滴涂机、紫外-可见分光光度计、透射电子显微镜（TEM）、扫描电子显微镜（SEM）、原子力显微镜（AFM）等。
五、实验步骤1. 制备二维材料悬浮液：将石墨烯或二硫化钼等二维材料前驱体分散于溶剂中，搅拌、超声处理，形成均匀分散的悬浮液；2. 制备二维材料薄膜：将悬浮液涂覆在基底材料上，通过旋涂或滴涂方法形成二维材料薄膜；3. 性能测试：采用紫外-可见分光光度计、TEM、SEM、AFM等仪器对二维材料薄膜进行性能测试。
六、实验结果与分析1. 二维材料悬浮液制备：通过搅拌、超声等手段，成功制备了均匀分散的二维材料悬浮液，悬浮液稳定性良好；2. 二维材料薄膜制备：通过旋涂或滴涂方法，成功制备了二维材料薄膜，薄膜厚度均匀，表面光滑；3. 性能测试：采用紫外-可见分光光度计、TEM、SEM、AFM等仪器对二维材料薄膜进行性能测试，结果表明：（1）二维材料薄膜具有优异的导电性，载流子迁移率较高；（2）二维材料薄膜具有较低的能量带隙，有利于光吸收；（3）二维材料薄膜具有较好的机械性能，如强度、韧性等。
最接近点对问题
.
11
能否在线性时间内找到p3,q3
❖ 第一步筛选：如果最近点对由S1中的p3和 S2中的q3组成，则p3和q3一定在划分线L 的距离d内。
需要计算P1中的每个点与. P2中的每个点的距离？ 12
并不必计算P1中的每个点与P2中的每个点的距离！O(n2)
❖ 第二步筛选：考虑P1中任意一点p，它若与 P2中的点q构成最接近点对的候选者，则必 有distance(p，q)＜d。满足这个条件的P2 中的点一定落在一个d×2d的矩形R中
点，则此点就是S2中最小点。
因此，我们用线性时间就能找到区间(m-d,m]和(m,m+d]中所
有点，即p3和q3。从而我们用线性时间就可以将S1的解和S2的
解合并成为S的解。
.
9
❖ public static double Cpair1(S,d) //找S中最接近点对的距离d
❖{
❖ n=|S|; //S中点的个数
若矩形R中有多于6个S中的 点，则由鸽舍原理易知至少有 一个(d/2)×(2d/3)的小矩形中 有2个以上S中的点。
设u，v是位于同一小矩形中 的2个点，则
(x(u) x(v))2 ( y(u) y(v))2 (d / 2)2 (2d / 3)2 25 d 2
distance(u,v)<d。这与d的. 意义相矛盾。 36 15
distance ( u, v)
(x(u) x(v))2 ( y(u) y(v))2 (z(u) z(v))2 (d / 2)2 (d / 2)2 (2d / 3)2 17 d 2 18
distance(u,v)<d。这与d的. 意义相矛盾。
23
报告最接近点对问题
报告最接近点对问题实验报告—最接近点对问题1、问题描述：给定n个点(xi,yi) 1<=i<=n，找出其中距离最近的两个点。
分析：采用分而治之设计技术，将平面上的n个点的集合S分成2个子集S1和S2，每个子集中约有n/2个点，然后在每个子集中递归地求其最接近点。
于是，原问题变为：（1）求S1中最近距离的两个点；（2）求S2中最近距离的两个点；（3）由（1）、（2）得到S中的最接近点。
有一个关键：如何实现组合解？（1）如果组成S中的最近距离点都在S1中，或都在S2中，则问题很容易解决！（2）如果组成S中的最近距离点分别在S1和S2中，那么，如何组合解？由鸽舍原理对于P1中任一点p，P2中最多只有6个点与它构成最近点的侯选者，于是组合解只需要检查6*（n/2)=3n对侯选点而不是n（2）/4个。
将p和P2中的所有S2的点投影到垂直线l上，由于能与p点构成侯选点的点都在矩形R中，所以它们在直线l上的投影点距p在l上的投影点的距离都小于最近距离。
从上面的分析知，这种点只有6个。
因此，若将P1和P2中的所有点按其y坐标排好序，则对P1中的所有点，对排好序的所有点作一次扫描，就可以找出所有最接近点对的侯选者，对P1中的每一点最多只要检查P2中排好序的相继的6个点。
2、基本算法：Public static double cpair2(S){如果点的个数n小于2，则显示提示信息：只有一个点不能求距离，终止算法；1．m=S中各点x坐标的中位数；(S为点的集合) 构造S1和S2；//S1={p∈S|x(p)<=m}, S2={p∈S|x(p)>m}2. d1=cpair2(S1); d2=cpair2(S2);3. dm=min(d1,d2);4. 设P1是S1中距垂直分割线l的距离在dm之内的所有点组成的集合；设P2是S2中距垂直分割线l的距离在dm之内的所有点组成的集合；将P1和P2中点依其y坐标值排序，并设X和Y是相应的已排好序的点列；5．通过扫描X以及对于X中每个点检查Y中与其距离在dm之内的所有点(最多6个).当X中的扫描指针逐次向上移动时，Y中的扫描指针可在宽为2dm的区间内移动；设dl是按这种扫描方式找到的点对间的最小距离；6．d=min(dm,dl);Return d；}3、实现环境和运行平台：采用java编写程序，jdk4.0编译调试,使用jdk的appletviewer显示运行结果。
二维辅助设计实验报告实验结果
二维辅助设计实验报告实验结果小伙伴们！今天咱们来唠唠这个二维辅助设计的实验结果。
这就像是一场充满未知的冒险，我一开始也心里没底儿呢。
在这个实验里啊，我们就像是一群探险家在二维世界里摸索。
首先，我们用了一款挺有名的二维辅助设计软件，那界面一打开，各种工具就像一群等待检阅的小兵，密密麻麻地排列着。
在绘图阶段，我本以为会顺风顺水的，结果呢？就像开着一辆老爷车，时不时地抛锚。
比如说，绘制一些复杂图形的时候，线条总是跟我对着干，就好像它们有自己的想法似的，扭扭曲曲的，一点都不乖。
我当时就想，这线条难道是成精了？不过，经过我一番折腾，反复调整参数，就像哄一个闹脾气的小孩，总算是把线条给驯服了。
再说说色彩填充方面。
我原本想象着能像画家一样，轻轻一点，颜色就能均匀漂亮地铺满整个区域。
可实际上呢？有时候就像拿着个漏勺去盛汤，颜色这儿一块那儿一块的，不均匀得很。
也许是我对色彩设置还不够了解吧，我觉得这里面肯定还有很多隐藏的小技巧等着我去挖掘。
在进行图形组合的时候，那感觉就像是在玩拼图，但是这个拼图的碎片还特别不听话。
有些图形叠在一起的时候，就像两个仇人见面，互相排斥，怎么也放不到合适的位置。
我当时就纳闷儿了，这难道是软件故意在整我吗？后来我才发现，原来是图层的顺序搞反了。
这就好比盖房子，你得先打好地基，再往上盖，图层顺序搞错了，可不就乱套了嘛。
经过一系列的折腾，最后的结果呢？虽然不是完美无缺，但也算是有点小成果。
就像一个刚学会走路的小孩，虽然走得歪歪扭扭，但好歹是能往前走了。
整体的设计图看起来有模有样的，各个部分也算是各司其职，没有再打架了。
不过，我知道这距离真正厉害的二维辅助设计还有很大的差距。
我就像站在山脚下，抬头望着山顶那些高手，心里满是羡慕。
我在想，他们是不是也经历过我这样的挣扎呢？还是说他们天生就是玩这个的料？你们有没有过类似的经历呢？反正我是觉得，这二维辅助设计啊，就像一个神秘的宝藏，越挖越觉得有意思，但是也越挖越发现自己懂得太少了。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验一课程名称：算法设计与实现实验名称：分治策略-一维点对问题实验日期：2019年3月20日仪器编号：007班级：数媒0000班姓名：郝仁学号0000000000实验内容请采用分治策略实现二维情形下的最近点对问题求解。
（1）二维平面上 n 个点集 X，Y 坐标的的排序请使用快递排序算法。
实验分析如果将点的距离两两计算出来需要O(n2)O(n2)的时间复杂度，显然不是最优方案。
先考虑一维数组情况，如果数组已经排好序，则只需要再遍历一遍，找到相邻值的最小距离即可，时间复杂度只是O(nlog(n))O(nlog(n))，但是这种方法不能推广到二维情况。
因为按照一个维度排序后，相邻点的最小距离并不是所有距离中的最小值。
这里可以采用分治法进行改进，首先将点集按照横坐标排序，根据其中心点将点集一分为二，构成最小距离的两个点要么同时在左边的子点集，要么同时在右边的子点集，或者一个在左边一个在右边。
前两种情况可以递归解决，这里主要考察第三种情况。
实验源代码// 二维点对ConsoleApplication1.cpp : 此文件包含 "main" 函数。
程序执行将在此处开始并结束。
//#include"pch.h"#include<time.h>#include<iostream>#include<cmath>using namespace std;const int M = 999;//用类PointX和PointY表示依x坐标和y坐标排好序的点class PointX {public:int operator<=(PointX a)const{return (x <= a.x);}int ID; //点编号float x, y; //点坐标};class PointY {public:int operator<=(PointY a)const{return(y <= a.y);}int p; //同一点在数组x中的坐标float x, y; //点坐标};float Random(int ax, int ay);template <class Type>float dis(const Type&u, const Type&v);bool Cpair2(PointX X[], int n, PointX& a, PointX& b, float& d);void closest(PointX X[], PointY Y[], PointY Z[], int l, int r, PointX& a, PointX& b, float& d);template <typename Type>void Copy(Type a[], Type b[], int left, int right);template <class Type>void Merge(Type c[], Type d[], int l, int m, int r);template <class Type>void MergeSort(Type a[], Type b[], int left, int right);int main(){srand((int)time(0));int length, ax, ay, aax, aay;cout <<"请输入点对坐标的取值范围：";cin >> aax >> aay;do { ax = aax; ay = aay; break; } while (aax < aay);cout <<"请输入点对数：";cin >> length;PointX X[M];cout <<"随机生成的二维点对为："<< endl;for (int i = 0; i < length; i++){X[i].ID = i;X[i].x = Random(ax,ay);X[i].y = Random(ax,ay);cout <<"("<< X[i].x <<","<< X[i].y <<") ";}PointX a;PointX b;float d;Cpair2(X, length, a, b, d);cout << endl;cout <<"最邻近点对为：("<< a.x <<","<< a.y <<")和("<< b.x <<","<< b.y <<") "<< endl;cout <<"最邻近距离为： "<< d << endl;system("pause");return 0;}float Random(int ax, int ay){int i = 0;float temp = -1;int Y = ay;int X = ax;//验证确实生成了[0,10]的随机数temp = rand() % (Y - X + 1) + X;//生成[0,10]的随机数return temp;}//平面上任意两点u和v之间的距离可计算如下template <class Type>inline float dis(const Type& u, const Type& v){float dx = u.x - v.x;float dy = u.y - v.y;return sqrt(dx*dx + dy * dy);bool Cpair2(PointX X[], int n, PointX& a, PointX& b, float& d){if (n < 2) return false;PointX* tmpX = new PointX[n];MergeSort(X, tmpX, 0, n - 1);PointY* Y = new PointY[n];for (int i = 0; i < n; i++) //将数组X中的点复制到数组Y中{Y[i].p = i;Y[i].x = X[i].x;Y[i].y = X[i].y;}PointY* tmpY = new PointY[n];MergeSort(Y, tmpY, 0, n - 1);PointY* Z = new PointY[n];closest(X, Y, Z, 0, n - 1, a, b, d);delete[]Y;delete[]Z;delete[]tmpX;delete[]tmpY;return true;}void closest(PointX X[], PointY Y[], PointY Z[], int l, int r, PointX& a, PointX& b, float& d) {if (r - l == 1) //两点的情形{a=X[l];b=X[r];d = dis(X[l], X[r]);return;}if (r - l == 2) //3点的情形{float d1 = dis(X[l], X[l + 1]);float d2 = dis(X[l + 1], X[r]);float d3 = dis(X[l], X[r]);if (d1 <= d2 && d1 <= d3){a=X[l];b=X[l + 1];d = d1;return;}if (d2 <= d3){a=X[l + 1];b=X[r];d = d2;}else {a=X[l];b=X[r];d = d3;}return;}//多于3点的情形，用分治法int m = (l + r) / 2;int f = l, g = m + 1;//在算法预处理阶段，将数组X中的点依x坐标排序，将数组Y中的点依y坐标排序//算法分割阶段，将子数组X[l:r]均匀划分成两个不想交的子集，取m=(l+r)/2 //X[l:m]和X[m+1:r]就是满足要求的分割。
for (int i = l; i <= r; i++){if (Y[i].p > m) Z[g++] =Y[i];else Z[f++] =Y[i];}closest(X, Z, Y, l, m, a, b, d);float dr;PointX ar, br;closest(X, Z, Y, m + 1, r, ar, br, dr);if (dr < d){a= ar;b= br;d = dr;}Merge(Z, Y, l, m, r);//重构数组Y//d矩形条内的点置于Z中int k = l;for (int i = l; i <= r; i++){if (fabs(X[m].x - Y[i].x) < d){Z[k++] =Y[i];}}//搜索Z[l:k-1]for (int i = l; i < k; i++){for (int j = i + 1; j < k && Z[j].y - Z[i].y < d; j++){float dp = dis(Z[i], Z[j]);if (dp < d){d = dp;a=X[Z[i].p];b=X[Z[j].p];}}}}template <class Type>void Merge(Type c[], Type d[], int l, int m, int r){int i = l, j = m + 1, k = l;while ((i <= m) && (j <= r)){if (c[i] <= c[j]){d[k++] = c[i++];}else{d[k++] = c[j++];}}if (i > m){for (int q = j; q <= r; q++){d[k++] = c[q];}}else{for (int q = i; q <= m; q++){d[k++] = c[q];}}}template <class Type>void MergeSort(Type a[], Type b[], int left, int right) {if (left < right){int i = (left + right) / 2;MergeSort(a, b, left, i);MergeSort(a, b, i + 1, right);Merge(a, b, left, i, right);//合并到数组bCopy(a, b, left, right);//复制回数组a }}template <typename Type>void Copy(Type a[], Type b[], int left, int right){for (int i = left; i <= right; i++)a[i] = b[i];}实验结果。