算法上机实验报告

课程实验报告课程名称：算法设计与分析

专业班级：信息安全1303

学号：U201315182

姓名：刘立鹏

指导教师：王多强

报告日期：2015-6-16

计算机科学与技术学院

目录

目录 (2)

实验一最近点对问题 (1)

1.1实验内容与要求 (1)

1.2算法设计 (1)

1.3 实验结果与分析 (2)

1.4编程技术与方法 (3)

1.5 源程序及注释 (3)

实验二大整数乘法 (8)

2.1实验内容与要求 (8)

2.2算法设计 (9)

2.3 实验结果与分析 (12)

2.4编程技术与方法 (12)

2.5 源程序及注释 (12)

实验三单源点 (14)

3.1实验内容与要求 (14)

3.2算法设计 (14)

3.3 实验结果与分析 (14)

3.4编程技术与方法 (16)

3.5 源程序及注释 (16)

实验四最优二分检索树 (19)

4.1实验内容与要求 (19)

4.2算法设计 (19)

4.3实验结果与分析 (20)

4.4源程序及注释 (22)

五、实验心得与体会 (25)

六、参考书目 (27)

实验一 最近点对问题

1.1 实验内容与要求

已知平面上分布着点集P 中的n 个点p 1,p 2,...p n ，点i 的坐标记为(x i ,y i )，1≤i≤n 。两点之间的距离取其欧式距离，记为22

)()(),(j i j i j i y y x x p p d -+-=

问题：找出一对距离最近的点。

注：允许两个点位于同一个位置，此时两点之间的距离为0 要求：用分治法实现最近点对的问题。

1.2 算法设计

（1）首先将所有的点按照x 坐标排序。排序过程需要O(nlogn)的时间，不会从整体上增加时间复杂度的数量级。

（2）划分：由于点已经按x 坐标排序，所以空间上可以“想象” 画一条垂线，作为分割线，将平面上的点集分成左、右两半P L 和P R 。

如下图所示：

d L

d C

d

R

分割线

P L P R

记, d L:P L中的最近点对距离；

d R:P R中的最近点对距离；

d C:跨越分割线的最近点对距离。

则，最近的一对点或者在P L中，或者在P R中，或者一个在P L中而另一个在P R中（跨越分割线）。

设点按它们的y坐标排序，如果p i和某个p j的y坐标相差大于δ，那么这样的p i可以终止计算，继续处理p i+1。算法描述如下：

for i=1 to numPointsInStrip do

for j=i+1 to numPointsInStrip do

if p i and p j's y-coordinates differ by more than δ

break;

else if dist(p i,p j)<δ

δ = dist(p i,p j);

1.3 实验结果与分析

实验数据：（1）点对数目：6

（2）点对坐标：（1,3）（2,5）（3,12）（5,8）（6,9）（7,15）

运行结果：

如图显示的是最近点对<5.00,8.00><6.00,9.00>的距离为1.41

1.4编程技术与方法

纵观整个过程，首先要对X坐标排序时间为O（NlogN），这是分治之前的预处理。然后问题分成了N/2规模，然后用Q（N）的复杂度得到中间的最近点对，然后可以在常数时间内得到最终的点对与最近值。So。。。T（N）=2T（N/2）+O（N），可以得到该算法的时间为O（NlogN）,在用分治法之前首先对Y坐标进行冒泡排序，将左右|d|范围里的点按Y值排序，然后依次从每个点出发做水平线，并在其之上d的距离做水平线，这样得到了一个2d*d 的矩形，显然，在此矩形之外的点无需开率啦，可以证明，矩形内最多容下8个点（包括自己本身）。所以意味着在排好序的Y坐标点中，只需要考虑其后的7个点就行了，此外已有人证明了事实上只需要考虑其后的4个点就行啦。可见，这些的时间复杂度最多Q （N）。

1.5 源程序及注释

#include

#include

#include

#define MAXLEN 200

int init(float *x,float *y,int *ind)

{

int n,i;

while(1==scanf("%d",&n))

{

if(n > 1) break;

printf("n invalid!\n");

}

for(i=0;i

{

scanf("%f%f",x+i,y+i);

ind[i]=i;

}

return n;

}

void pre_sort(float *x,float *y,int *ind,int n)

{//must finish in O(nlogn) but here using normorl sort method //bubble sort

int i,j;

int tmp;

float tmp_y,tmp_x;

for(i=0;i

for(j=n-1;j > i;j--)

if(x[j-1] > x[j])

{

//swap x

tmp_x=x[j-1];

x[j-1]=x[j];

x[j]=tmp_x;

//swap y

tmp_y=y[j-1];

y[j-1]=y[j];

y[j]=tmp_y;

//swap ind no need now!

/*tmp=ind[j-1];

ind[j-1]=ind[j];

ind[j]=tmp;*/

}

for(i=0;i

for(j=n-1;j > i;j--)

if(y[j-1] > y[j])

{

//swap y

tmp_y=y[j-1];

y[j-1]=y[j];

y[j]=tmp_y;

//swap ind

tmp=ind[j-1];

ind[j-1]=ind[j];

ind[j]=tmp;

}

}

float get_pair_len(float x1,float y1,float x2,float y2)

{

return sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));

}

void find_closest_pair(int st,int ed,float *x,float *y,int *ind,float *closest,float *x1,float *y1,float *x2,float *y2)

{//key code

if(ed-st == 1){//only 2 point

*closest=get_pair_len(x[ind[0]],y[0],x[ind[1]],y[1]);

*x1=x[ind[0]];

*y1=y[0];

*x2=x[ind[1]];

*y2=y[1];

}

else if(ed-st ==2)

{//only 3 point

float len;

*closest=get_pair_len(x[ind[0]],y[0],x[ind[1]],y[1]);

*x1=x[ind[0]];

*y1=y[0];

*x2=x[ind[1]];

*y2=y[1];

len=get_pair_len(x[ind[0]],y[0],x[ind[2]],y[2]);

if(len < *closest){

*closest=len;

*x1=x[ind[0]];

*y1=y[0];

*x2=x[ind[2]];

*y2=y[2];

}

len=get_pair_len(x[ind[1]],y[1],x[ind[2]],y[2]);

if(len < *closest){

*closest=len;

*x1=x[ind[1]];

*y1=y[1];

*x2=x[ind[2]];

*y2=y[2];

}

}else{//at least 4 points

int i,cl,cr,ct;

int mid;

float t_c1,t_c2;

float t_c1_x1,t_c1_y1,t_c1_x2,t_c1_y2;

float t_c2_x1,t_c2_y1,t_c2_x2,t_c2_y2;

float *yl,*yr,*yct;

int *indl,*indr,*indct;

mid=(st+ed)/2;

yl=(float*)malloc((mid-st+1)*sizeof(float));

indl=(int*)malloc((mid-st+1)*sizeof(int));

yr=(float*)malloc((ed-mid)*sizeof(float));

indr=(int*)malloc((ed-mid)*sizeof(int));

if(!yl || !yr || !indl || !indr) exit(-2);//non enough mm

for(i=0,cl=0,cr=0;i<=ed-st;i++)

{//store new order y&ind

if(ind[i] <= mid){

yl[cl]=y[i];

indl[cl]=ind[i];

cl++;

}

else{

yr[cr]=y[i];

indr[cr]=ind[i];

cr++;

}

}

//divided

find_closest_pair(st,mid,x,yl,indl,&t_c1,&t_c1_x1,&t_c1_y1,&t_c1_x2,&t_c1_y2);

find_closest_pair(mid+1,ed,x,yr,indr,&t_c2,&t_c2_x1,&t_c2_y1,&t_c2_x2,&t_c2_y2);

if(t_c1 < t_c2){

*closest=t_c1;

*x1=t_c1_x1;

*y1=t_c1_y1;

*x2=t_c1_x2;

*y2=t_c1_y2;

}

else{

*closest=t_c2;

*x1=t_c2_x1;

*y1=t_c2_y1;

*x2=t_c2_x2;

*y2=t_c2_y2;

}//get the closest pair between the two part(L&R)

int v,ve;

float closest_tmp;

float part_line=(x[mid]+x[mid+1])/2.0;

yct=(float*)malloc((ed-st+1)*sizeof(float));

indct=(int*)malloc((ed-st+1)*sizeof(int));

//get all the y in the rect

for(i=0,ct=0;i<=ed-st;i++)

if(x[ind[i]]>part_line-*closest && x[ind[i]]

yct[ct]=y[i];

indct[ct]=ind[i];

ct++;

}

//check followed the 4 points

if(ct > 1){

for(i=0;i< ct-1;i++){

ve=(i+4 < ct-1 ? i+4:ct-1);

v=i+1;

while(v<=ve && yct[v]-yct[i] <=*closest){

closest_tmp=get_pair_len(x[indct[i]],yct[i],x[indct[v]],yct[v]);

if(closest_tmp < *closest){

*closest=closest_tmp;

*x1=x[indct[i]];

*y1=yct[i];

*x2=x[indct[v]];

*y2=yct[v];

}

v++;

}

}

}

free(yl);

free(yr);

free(indl);

free(indr);

free(yct);

free(indct);

}

}

int main()

{

float X[MAXLEN],Y[MAXLEN];

int IND[MAXLEN],n;

n=init(X,Y,IND);

float closest,x1,y1,x2,y2;

pre_sort(X,Y,IND,n);

find_closest_pair(0,n-1,X,Y,IND,&closest,&x1,&y1,&x2,&y2);

printf("the closest value is:%-4.2f (%-4.2f,%-4.2f) (%-4.2f,%-4.2f)\n",closest,x1,y1,x2,y2);

return 0;

}

实验二大整数乘法

2.1实验内容与要求

利用分治法设计一个计算两个n位的大整数相乘的算法，要求计算时间低于O(n2)。

大整数（big integer）：位数很多的整数，普通的计算机不能直

接处理，如：9834975972130802345791023498570345

显然，这样的整数普通的计算机和程序语言是无法直接表示的。

大整数运算：给定两个n位的整数I，J,

加、减法：可以用O(n)的时间计算出I+J和I-J，即使I、J是大整数；

乘法：若I、J超过普通计算机可以表示的数据范围，怎么计算IxJ?

如I = 9834975972135791023498570345

J = 3432450018098972347892345023

2.2算法设计

要求两个位数为 n的整数 A和B的乘积AxB。如果用普通的乘法的话，要用n2次乘法和n-1次加法，所以时间复杂度是O(n2)。

如果把 A分解成 A=a*10n/2+b

把B分解成B=c*10n/2+d

那么AxB=( a*10n/2+b)x(c*10n/2+d)=ac*10n+(ad+bc)*10n/2+bd = ac*10n+((a+b)(c+d)-ac-bd)*10n/2+bd

这样的话是3次乘法6次加法，当然，可以递归计算ac,bd,(a+d)(c+d)

由此可以产生下面递推公式：

T(n)=3T(n/2)+bn; n>1

T(n)=d; n=1

b d是大于 0的常量。

根据主定理 T(n)=n1.59 (1.59=log23)

算法实现：

//大整数乘法

public class Multiplication {

/**

* @param args

*/

public long mutiply(long a ,long b){

long n=getDigitsNum(a); //位数

if(n<4) return a*b;

long al=a%(int)Math.pow(10, n/2);//每个数字分成两部分 long au=a/(int)Math.pow(10, Math.ceil(n/2));

long bl=b%(int)Math.pow(10, n/2);

long bu=b/(int)Math.pow(10, Math.ceil(n/2));

long ac=mutiply(au,bu); //ac

long bd=mutiply(al,bl); //bd

long abcd=mutiply(au+al,bu+bl); //(a+b)*(c+d)

long r=ac*(long)Math.pow(10, 2*(n/2))+(abcd-acbd)*(long)Math.pow(10, n/2)+bd;

return r;

}

//计算位数,a与b的位数必须相等。时间复杂度是 O(n)

public int getDigitsNum(long a){

int i=0;

while(a>0){

i++;

a=a/10;

}

return i;

}

public static void main(String[] args) {

// TODO Auto-generated method stub

long a=1683527,b=1528719;

long result=new Multiplication().mutiply(a, b);

System.out.println(a*b);

System.out.println(result);

}

}

2.3 实验结果与分析

实验测试数据：1111111111*1111111111

123456789*999888666555222

程序运行结果：（1）

（2）

经计算器验算，计算结果均正确说明程序具有可行性。

2.4编程技术与方法

利用分治法进行编程时往往计算量过大时就会溢出，此时采取数组的方式来存放数据，并且将其以字符串的形式存储并输出，每四位存储在一个数组中由高到低，并且将进位作为一个单独的数组在下一个高位数组中进行运算时加进去，其输出数组由高位到地位组成一个新的字符串，该字符串显示的结果就是运算的结果了！

2.5 源程序及注释

#include

#include

void a2d(int x[],char a[])

{

int i,j;

for(i=0;i<500;i++)

x[i]=0;

j=strlen(a)-1;

for(i=0;j>=0;j--,i++)

x[i]=a[j]-'0';

}

int my_len(int x[])

{

int i;

for(i=499;i>=0&&x[i]==0;i--);

return i<0?0:i;

}

void multi(int x[],int y[])

{

int sum[500]={0},i,j,k,lx=my_len(x),ly=my_len(y);

for(i=0;i<=lx;i++)

for(j=0;j<=ly;j++)

sum[i+j]+=x[i]*y[j];

for(i=0;i<499;i++)

{

sum[i+1]+=sum[i]/10;

sum[i]%=10;

x[i]=sum[i];

}

}

int main()

{

int i,x[500],y[500];

char a[500],b[500];

while(scanf("%s%s",a,b)!=EOF)

{

a2d(x,a);

a2d(y,b);

multi(x,y);

i=my_len(x);

for(;i>=0;i--)

printf("%d",x[i]);

puts("");

}

return 0;

}

实验三单源点

3.1实验内容与要求

给定一个带权有向图G=（V,E），其中每条边的权是非负实数，给定V中的一个定点，称为源。计算从源到所有定点的最短路长度。这里的路的长度是指路上个边权之和。这个问题称之为单源点最短路径。利用贪心算法设计一个程序来实现单源点最短距离的求取。

3.2算法设计

Dijkstra算法是解单源最短路径的一个贪心算法其基本思想是，设置顶点集合S并不断的做贪心选择来扩充这个集合。一个顶点属于S 当且仅当从源点到该顶点的最短路径长度已知。初值时，S中仅含有源，设u是G中某一个顶点，把从源到u且中间只经过S中的顶点的路径（称为特殊路径）长度用数组dist记录，Dijkstra算法每次从

V-S 中取出具有最短特殊路径长度的顶点u，将u添加到S中，同时对数组dist做必要的修改，一旦S中包含了V中所有的顶点，dist

就记录了从源到所有其他顶点的最短路径长度。

3.3 实验结果与分析

测试数据：

实验运行结果：

其中5 7表示这是一个有5个顶点7条边组成的有向带权图，

0到1的距离为100其余以此类推，输入源点0，则其单源点最短路径和距离分别为：

0-1路径为0-4-3-1距离为70

0-2路径为0-2距离为30

其余以此类推，经手动验证，说明程序具有可行性，结果正确。

3.4编程技术与方法

该实验实现的主要方法是Dijkstra算法，试验程序中主要利用数组来存储其有向带权图的邻接矩阵，利用数组来进行矩阵的一些运算。为了求出最短路径，Dijkstra就提出了以最短路径长度递增，逐次生成最短路径的算法。譬如对于源顶点V0，首先选择其直接相邻的顶点中长度最短的顶点Vi，那么当前已知可得从V0到达Vj顶点的最短距离dist[j]=min{dist[j],dist[i]+matrix[i][j]}。根据这种思路：

假设存在G=，源顶点为V0，U={V0},dist[i]记录V0到i的最短距离，path[i]记录从V0到i路径上的i前面的一个顶点。

1.从V-U中选择使dist[i]值最小的顶点i，将i加入到U中；

2.更新与i直接相邻顶点的dist。(dist[j]=min{dist[j],dist[i]+matrix[i][j]})

3.直到U=V，停止。

3.5 源程序及注释

/*Dijkstra求单源最短路径2015.6.17*/

#include

#include

#include

#define M 100

#define N 100

using namespace std;

typedef struct node

{

int matrix[N][M]; //邻接矩阵

int n; //顶点数

int e; //边数

}MGraph;

void DijkstraPath(MGraph g,int *dist,int *path,int v0) //v0表示源顶点

{

int i,j,k;

bool *visited=(bool *)malloc(sizeof(bool)*g.n);

for(i=0;i

{

if(g.matrix[v0][i]>0&&i!=v0)

{

dist[i]=g.matrix[v0][i];

path[i]=v0; //path记录最短路径上从v0到i的前一个顶点}

else

{

dist[i]=INT_MAX; //若i不与v0直接相邻，则权值置为无穷大

path[i]=-1;

}

visited[i]=false;

path[v0]=v0;

dist[v0]=0;

}

visited[v0]=true;

for(i=1;i

{

int min=INT_MAX;

int u;

for(j=0;j

{

if(visited[j]==false&&dist[j]

{

min=dist[j];

u=j;

}

}

visited[u]=true;

for(k=0;k

{

if(visited[k]==false&&g.matrix[u][k]>0&&min+g.matrix[u][k]

{

dist[k]=min+g.matrix[u][k];

path[k]=u;

}

}

}

}

void showPath(int *path,int v,int v0) //输出最短路径上的各个顶点{

stack s;

int u=v;

while(v!=v0)

{

s.push(v);

v=path[v];

}

s.push(v);

while(!s.empty())

{

cout<

s.pop();

}

}

int main(int argc, char *argv[])

{

int n,e; //表示输入的顶点数和边数

while(cin>>n>>e&&e!=0)

{

int i,j;

int s,t,w; //表示存在一条边s->t,权值为w

MGraph g;

int v0;

int *dist=(int *)malloc(sizeof(int)*n);

int *path=(int *)malloc(sizeof(int)*n);

for(i=0;i

for(j=0;j

g.matrix[i][j]=0;

g.n=n;

g.e=e;

for(i=0;i

{

cin>>s>>t>>w;

g.matrix[s][t]=w;

}

cin>>v0; //输入源顶点

DijkstraPath(g,dist,path,v0);

for(i=0;i

{

if(i!=v0)