用蛮力法和分治法解决最近对问题Word格式文档下载.docx
《用蛮力法和分治法解决最近对问题Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《用蛮力法和分治法解决最近对问题Word格式文档下载.docx（14页珍藏版）》请在冰豆网上搜索。
if（d<
minDist）{
minDist=d;
index1=i;
index2=j;
}
returnminDist;
}
程序：
importjava.util.*;
publicclassClosestPair1{
publicstaticvoidmain（String[]args）
/**
*输入需要比较的点的对数存在变量n中
*/
Scannerin=newScanner（System.in）;
System.out.println（"
Howmanypairsofpointstocompare?
（有多少对点需要比较?
）"
）;
intn=in.nextInt（）;
int[]x=newint[n];
int[]y=newint[n];
*输入这些点的横坐标和纵坐标分别存储在x[n]和y[n]
Pleaseenterthesepoints,X-coordinate（请输入这些点,横坐标）:
"
for（inti=0;
i<
i++）
x[i]=in.nextInt（）;
Pleaseenterthesepoints,Y-coordinate（请输入这些点,纵坐标）:
y[i]=in.nextInt（）;
doubleminDist=Double.POSITIVE_INFINITY;
doubled;
intindexI=0;
intindexJ=0;
*求解最近对距离存于minDist中
doublestartTime=System.currentTimeMillis（）;
//startTime
n-1;
for（intj=i+1;
j<
j++）
d=Math.sqrt（（x[i]-x[j]）*（x[i]-x[j]）+（y[i]-y[j]）*（y[i]-y[j]））;
if（d<
minDist）
indexI=i;
indexJ=j;
}
doubleendTime=System.currentTimeMillis（）;
//endTime
*打印输出最后求出的结果，最近的是哪两个点，以及最近距离和程序用的时间
Theclosestpairis:
（"
+x[indexI]+"
"
+y[indexI]+"
）and（"
+x[indexJ]+"
+y[indexJ]+"
Theclosestdistanceis"
+minDist）;
BasicStatementstake（基本语句用时）"
+（endTime-startTime）+"
milliseconds!
}
运行：
分治算法描述：
可以划一条垂线，把点集分成两半：
PL和PR。
于是最近点对或者在PL中，或者在PR中，或者PL，PR各有一点。
把三种距离情况定义为dL,dR,dC.
其中dL,dR可以递归求解，于是问题就变为计算dC。
设s=min（dL,dR）.通过观察能得出结论：
如果dC<
s,则只需计算dC。
如果dC满足这样的条件，则决定dC的两点必然在分割线的s距离之内，称之为带（strip）
否则不可能满足dC<
s,于是缩小了需要考虑的点的范围。
publicclassClosestPair2
{
*输入这些点的横坐标和纵坐标，存储在点数组S[n]中
Pleaseenterthesepoints,X-coordinateandY-coordinate.（请输入这些点，x坐标和y坐标）：
Point[]S=newPoint[n];
//starttime
intx=in.nextInt（）;
inty=in.nextInt（）;
S[i]=newPoint（x,y）;
+S[i].getX（）+"
+S[i].getY（）+"
*求出这点的x坐标的中位数mid
intminX=（int）Double.POSITIVE_INFINITY;
intmaxX=（int）Double.NEGATIVE_INFINITY;
if（S[i].getX（）<
minX）
minX=S[i].getX（）;
if（S[i].getX（）>
maxX）
maxX=S[i].getX（）;
intmid=（minX+maxX）/2;
*以mid为界把S中的点分为两组分别存放在范型数组列表point1和point2中
ArrayListpoint1=newArrayList（）;
ArrayListpoint2=newArrayList（）;
=mid）
point1.add（S[i]）;
else
point2.add（S[i]）;
*将范型数组列表转换为数组类型S1和S2
Point[]S1=newPoint[point1.size（）];
Point[]S2=newPoint[point2.size（）];
point1.toArray（S1）;
point2.toArray（S2）;
*将S1和S2中的点按x坐标升序排列
sortX（S1）;
sortX（S2）;
*打印输出排序后S1和S2的点
System.out.print（"
ThepointsinS1are:
S1.length;
+S1[i].getX（）+"
+S1[i].getY（）+"
）"
System.out.println（）;
ThepointsinS2are:
S2.length;
+S2[i].getX（）+"
+S2[i].getY（）+"
*求S1中点的最近对及其距离并打印输出结果
*/
doubleminDist1=Double.POSITIVE_INFINITY;
intindexI1=0;
intindexJ1=0;
S1.length-1;
doubled=Math.sqrt（Math.pow（（S1[i].getX（）-S1[j].getX（））,2）+Math.pow（（S1[i].getY（）-S1[j].getY（））,2））;
minDist1）
minDist1=d;
indexI1=i;
indexJ1=j;
TheclosestpairinS1is:
"
+"
+S1[indexI1].getX（）+"
+S1[indexI1].getY（）+"
+
and（"
+S1[indexJ1].getX（）+"
+S1[indexJ1].getY（）+"
andthedistanceis"
+minDist1）;
*求S2中点的最近对及其距离并打印输出结果
doubleminDist2=Double.POSITIVE_INFINITY;
intindexI2=0;
intindexJ2=0;
S2.length-1;
doubled=Math.sqrt（Math.pow（（S2[i].getX（）-S2[j].getX（））,2）+Math.pow（（S2[i].getY（）-S2[j].getY（））,2））;
minDist2）
minDist2=d;
indexI2=i;
indexJ2=j;
TheclosestpairinS2is:
+S2[indexI2].getX（）+"
+S2[indexI2].getY（）+"
+S2[indexJ2].getX（）+"
+S2[indexJ2].getY（）+"
+minDist2）;
doubled1=Math.min（minDist1,minDist2）;
*在S1,S2中收集距离中线两侧小于dl的点，分别存在P1[]和P2[]中
ArrayList<
Point>
pp1=newArrayList<
（）;
pp2=newArrayList<
if（（mid-S1[i].getX（））<
d1）
pp1.add（S1[i]）;
if（（S2[i].getX（）-mid）<
pp2.add（S2[i]）;
Point[]P1=newPoint[pp1.size（）];
Point[]P2=newPoint[pp2.size（）];
pp1.toArray（P1）;
pp2.toArray（P2）;
*将P1和P2中的点按Y坐标升序排列
sortY（P1）;
sortY（P2）;
*求解P1和P2两者之间可能的最近对距离
doubled2=Double.POSITIVE_INFINITY;
P1.length;
for（intj=0;
P2.length;
if（Math.abs（P1[i].getY（）-P2[j].getY（））<
doubletemp=Math.sqrt（Math.pow（（P1[i].getX（）-P2[j].getX（））,2）+Math.pow（（P1[i].getX（）-P2[j].getX（））,2））;
if（temp<
d2）
d2=temp;
//endtime
ThepointsinP1are:
+P1[i].getX（）+"
+P1[i].getY（）+"
ThepointsinP2are:
+P2[i].getX（）+"
+P2[i].getY（）+"
d2="
+d2）;
doubleminDist=Math.min（d1,d2）;
*设计按点Point的x坐标升序排列的函数sortX
publicstaticvoidsortX（Point[]p）
p.length-1;
p.length-1-i;
if（p[j].getX（）>
p[j+1].getX（））
intt=p[j].getX（）;
p[j].setX（p[j+1].getX（））;
p[j+1].setX（t）;
intn=p[j].getY（）;
p[j].setY（p[j+1].getY（））;
p[j+1].setY（n）;
*设计按点Point的y坐标升序排列的函数sortY
publicstaticvoidsortY（Point[]p）
if（p[j].getY（）>
p[j+1].getY（））
intt=p[j].getY（）;
p[j+1].setY（t）;
intn=p[j].getX（）;
p[j+1].setX（n）;
/**
*建立自己的类Point
classPointimplementsCloneable
publicPoint（）
x=0;
y=0;
publicPoint（intx,inty）
this.x=x;
this.y=y;
publicvoidsetX（intx）
publicvoidsetY（inty）
publicintgetX（）
returnx;
publicintgetY（）
returny;
privateintx;
privateinty;
升级会员 