用蛮力法和分治法解决最近对问题.docx

用蛮力法和分治法解决最近对问题.docx

《用蛮力法和分治法解决最近对问题.docx》由会员分享，可在线阅读，更多相关《用蛮力法和分治法解决最近对问题.docx（14页珍藏版）》请在冰豆网上搜索。

用蛮力法和分治法解决最近对问题

算法分析与复杂型设计作业

学院计算机与控制工程学院

专业计算机软件与理论

班级Y130701

学生姓名郑晓璐

流水号20130789

2014年4月

问题：

设p1=（x1,y1）,p2=（x2,y2）,…,pn=（xn,yn）是平面上n个点构成的集合S，设计算法找出集合S中距离最近的点对。

蛮力算法描述：

intClosestPoints（intn,intx[],inty[]）{

minDist=Double.POSITIVE_INFINITY;;

for（i=1;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=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]

*/

System.out.println（"Pleaseenterthesepoints,X-coordinate（请输入这些点,横坐标）:

"）;

for（inti=0;i

{

x[i]=in.nextInt（）;

}

System.out.println（"Pleaseenterthesepoints,Y-coordinate（请输入这些点,纵坐标）:

"）;

for（inti=0;i

{

y[i]=in.nextInt（）;

}

doubleminDist=Double.POSITIVE_INFINITY;

doubled;

intindexI=0;

intindexJ=0;

/**

*求解最近对距离存于minDist中

*/

doublestartTime=System.currentTimeMillis（）;//startTime

for（inti=0;i

{

for（intj=i+1;j

{

d=Math.sqrt（（x[i]-x[j]）*（x[i]-x[j]）+（y[i]-y[j]）*（y[i]-y[j]））;

if（d

{

minDist=d;

indexI=i;

indexJ=j;

}

}

}

doubleendTime=System.currentTimeMillis（）;//endTime

/**

*打印输出最后求出的结果，最近的是哪两个点，以及最近距离和程序用的时间

*/

System.out.println（"Theclosestpairis:

（"+x[indexI]+","+y[indexI]+"）and（"+x[indexJ]+","+y[indexJ]+"）"）;

System.out.println（"Theclosestdistanceis"+minDist）;

System.out.println（"BasicStatementstake（基本语句用时）"+（endTime-startTime）+"milliseconds!

"）;

}

}

运行：

分治算法描述：

   可以划一条垂线，把点集分成两半：

PL和PR。

于是最近点对或者在PL中，或者在PR中，或者PL，PR各有一点。

把三种距离情况定义为dL,dR,dC.

    其中dL,dR可以递归求解，于是问题就变为计算dC。

设s=min（dL,dR）.通过观察能得出结论：

如果dC

如果dC满足这样的条件，则决定dC的两点必然在分割线的s距离之内，称之为带（strip）

否则不可能满足dC

程序：

importjava.util.*;

publicclassClosestPair2

{

publicstaticvoidmain（String[]args）

{

/**

*输入需要比较的点的对数存在变量n中

*/

Scannerin=newScanner（System.in）;

System.out.println（"Howmanypairsofpointstocompare?

（有多少对点需要比较?

）"）;

intn=in.nextInt（）;

/**

*输入这些点的横坐标和纵坐标，存储在点数组S[n]中

*/

System.out.println（"Pleaseenterthesepoints,X-coordinateandY-coordinate.（请输入这些点，x坐标和y坐标）：

"）;

Point[]S=newPoint[n];

doublestartTime=System.currentTimeMillis（）;//starttime

for（inti=0;i

{

intx=in.nextInt（）;

inty=in.nextInt（）;

S[i]=newPoint（x,y）;

System.out.println（"（"+S[i].getX（）+","+S[i].getY（）+"）"）;

}

/**

*求出这点的x坐标的中位数mid

*/

intminX=（int）Double.POSITIVE_INFINITY;

intmaxX=（int）Double.NEGATIVE_INFINITY;

for（inti=0;i

{

if（S[i].getX（）

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（）;

for（inti=0;i

{

if（S[i].getX（）<=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:

"）;

for（inti=0;i

System.out.print（"（"+S1[i].getX（）+","+S1[i].getY（）+"）"）;

System.out.println（）;

System.out.print（"ThepointsinS2are:

"）;

for（inti=0;i

System.out.print（"（"+S2[i].getX（）+","+S2[i].getY（）+"）"）;

System.out.println（）;

/**

*求S1中点的最近对及其距离并打印输出结果

*/

doubleminDist1=Double.POSITIVE_INFINITY;

intindexI1=0;

intindexJ1=0;

for（inti=0;i

{

for（intj=i+1;j

{

doubled=Math.sqrt（Math.pow（（S1[i].getX（）-S1[j].getX（））,2）+Math.pow（（S1[i].getY（）-S1[j].getY（））,2））;

if（d

{

minDist1=d;

indexI1=i;

indexJ1=j;

}

}

}

System.out.println（"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;

for（inti=0;i

{

for（intj=i+1;j

{

doubled=Math.sqrt（Math.pow（（S2[i].getX（）-S2[j].getX（））,2）+Math.pow（（S2[i].getY（）-S2[j].getY（））,2））;

if（d

{

minDist2=d;

indexI2=i;

indexJ2=j;

}

}

}

System.out.println（"TheclosestpairinS2is:

"+"（"+S2[indexI2].getX（）+","+S2[indexI2].getY（）+"）"+

"and（"+S2[indexJ2].getX（）+","+S2[indexJ2].getY（）+"）"+",andthedistanceis"+minDist2）;

doubled1=Math.min（minDist1,minDist2）;

/**

*在S1,S2中收集距离中线两侧小于dl的点，分别存在P1[]和P2[]中

*/

ArrayListpp1=newArrayList（）;

ArrayListpp2=newArrayList（）;

for（inti=0;i

{

if（（mid-S1[i].getX（））

pp1.add（S1[i]）;

}

for（inti=0;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;

for（inti=0;i

{

for（intj=0;j

{

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=temp;

}

}

}

doubleendTime=System.currentTimeMillis（）;//endtime

/**

*打印输出最后求出的结果，最近的是哪两个点，以及最近距离和程序用的时间

*/

System.out.print（"ThepointsinP1are:

"）;

for（inti=0;i

System.out.print（"（"+P1[i].getX（）+","+P1[i].getY（）+"）"）;

System.out.println（）;

System.out.print（"ThepointsinP2are:

"）;

for（inti=0;i

System.out.print（"（"+P2[i].getX（）+","+P2[i].getY（）+"）"）;

System.out.println（）;

System.out.println（"d2="+d2）;

doubleminDist=Math.min（d1,d2）;

System.out.println（"Theclosestdistanceis"+minDist）;

System.out.println（"BasicStatementstake（基本语句用时）"+（endTime-startTime）+"milliseconds!

"）;

}

/**

*设计按点Point的x坐标升序排列的函数sortX

*/

publicstaticvoidsortX（Point[]p）

{

for（inti=0;i

{

for（intj=0;j

{

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）

{

for（inti=0;i

{

for（intj=0;j

{

if（p[j].getY（）>p[j+1].getY（））

{

intt=p[j].getY（）;

p[j].setY（p[j+1].getY（））;

p[j+1].setY（t）;

intn=p[j].getX（）;

p[j].setX（p[j+1].getX（））;

p[j+1].setX（n）;

}

}

}

}

}

/**

*建立自己的类Point

*/

classPointimplementsCloneable

{

publicPoint（）

{

x=0;

y=0;

}

publicPoint（intx,inty）

{

this.x=x;

this.y=y;

}

publicvoidsetX（intx）

{

this.x=x;

}

publicvoidsetY（inty）

{

this.y=y;

}

publicintgetX（）

{

returnx;

}

publicintgetY（）

{

returny;

}

privateintx;

privateinty;

}