网络布线课题报告Word文档格式.docx

网络布线课题报告Word文档格式.docx

《网络布线课题报告Word文档格式.docx》由会员分享，可在线阅读，更多相关《网络布线课题报告Word文档格式.docx（11页珍藏版）》请在冰豆网上搜索。

给出最优连接方案中每两台相邻计算机之间的距离，以及总的电缆长度。

提高要求：

参考图2，用图形化的方式显示结果，包括点的坐标、最优路径、相邻计算机之间的距离。

（二）设计

A.设计思想

根据上述需求，可知符合用贪婪算法解决的要求。

贪婪算法的总体思想是从问题的某一个初始解出发逐步逼近给定的目标，以尽可能快的地求得更好的解。

当达到某算法中的某一步不能再继续前进时，算法停止。

故此题可在各台计算机之中选取权值最小的一个边并记录他的两个顶点，并将它们标识为已选顶点和始出发的两点，通过这两个顶点分别向各个未选定顶点连接线段，并求出他们的权值，继而在这些权值中选取一个最小的权值，并将这条权值的边的另一顶点标志为已选顶点和出发点，原顶点不再作为始出发点，即始终保持两个始出发点，接着重复这一操作直至所有的点都成为已选顶点贪婪算法结束，最后再将各点在坐标图中表示出来，连接成路线，结束程序。

B.程序框图

步骤

算法思想

实现方法

1.贪婪算法前的准备

A．对点定义，求两点间距离函数声明；

B．初始化各点信息及边的权值；

1使用结构体structpoint储存点的x，y坐标；

2使用数组g[i][j]代表i点到j点间距离，数组path[i][j]代表i和j间路径和数组nod[i]代表i点的访问次数。

2.贪婪算法的实现

A．首先搜索出最短的两点

B．以两端点为起点，继续求未选边中最短边；

C重复B步骤直至所有顶点选中；

1.通过循环函数搜索所有边中最小的边，并把他的两个顶点记为p1，p2作为初始顶点；

2．通过一个标志数据flag是否为0来判断初始顶点中哪个顶点延伸边最短；

3.将求出的延伸边的另一顶点代替原顶点作为初始顶点，继续寻找至所有顶点选中结束。

3.坐标图的实现（注：

本部分属提高要求）

说明：

由于输出的限制，只能对一定的数据实行坐标图

1.首先对数据判断是否满足条件；

2.对满足条件的数据进行坐标构造；

1.设一个a作为是否含有两点y值相同的数据和为小数的标志；

2对数据的y值由大到小排序，以便构造坐标图；

3.在确定某一点在坐标图的位置时，根据数据的y值与上一数据y值之差来判断该点相对于上一点应下移多少行，根据x值确定应右移多少格；

4.对不能生成坐标图的情况加以说明。

（三）用户手册

1.首先根据提示输入电脑的台数，如输入“5”；

2.根据提示在相应点的坐标上输入初始值，如：

要输入0点坐标（2，3）

屏幕显示请输入标号为0的点的坐标：

x：

用户需输入“2”，

接着屏幕显示y：

用户则需要输入“3”；

3根据运算结果得知需连接哪些边，以及所求每边耗材和总的耗材。

（四）调试及测试

1．可显示坐标图的情况：

2．不可显示坐标图的情况：

（五）进一步改进

（1）目前程序中，对1.含有两点在x相同情况下y值相同或点xy坐标含有小数的数据均不能构造坐标图2.不能实现连接顶点，这两个缺陷可考虑用mfc来解决,使坐标和连线的边均可视化

（2）由于在网络布线或其他类似的实际情况下不一定需要满足只有一个起点和终点，而只需满足所用耗材最小，可归纳为最小生成树的求解，此时可考虑用prim算法来实现。

（六）附录源程序

#include<

iostream.h>

math.h>

#defineMAX100000000;

structpoint//对点定义

{

doublex;

doubley;

};

doubledst（structpoint,structpoint）;

//求两点间距离函数声明

/*1.贪婪算法前的准备*/

voidmain（）

inti=0;

intj=0;

intn;

cout<

<

"

请输入电脑的数目:

endl;

cin>

>

n;

structpoint*p=newstructpoint[n];

int*nod=newint[n];

//nod[i]代表i点的访问次数

while（i<

n）//初始化各点（坐标，和被访问次数）

{

doublet1,t2;

cout<

请输入标号为"

i<

的点坐标:

x:

;

t1;

y:

cin>

t2;

p[i].x=t1;

p[i].y=t2;

nod[i]=0;

i++;

}

//（g[i][j]代表i点到j点间距离path[i][j]代表i和j间路径）

double**g=newdouble*[n];

int**path=newint*[n];

for（i=0;

i++）//初始化g和path

g[i]=newdouble[n];

path[i]=newint[n];

i++）

for（j=0;

j<

j++）

if（i==j）

g[i][j]=0;

else

g[i][j]=dst（p[i],p[j]）;

path[i][j]=0;

/*2.贪婪算法*/

doublemin=MAX;

//首先搜索出最短的两点p1->

p2，并记录他们的名称和距离

intp1=0;

intp2=0;

if（g[i][j]<

=min&

&

i!

=j）//如果i和j点不重合，且不是无穷大

min=g[i][j];

if（i==p2&

j==p1）//出现i到j和j到i为同一情况

continue;

p1=i;

p2=j;

path[p1][p2]=1;

path[p2][p1]=1;

nod[p1]++;

nod[p2]++;

min=MAX;

intk1,k2;

n-2;

j++）//以两端点为起点，继续求未选边中最短边

intflag=0;

//flag用来标志一条边中哪个顶点延伸边最短

if（g[p1][i]<

path[p1][i]==0&

p1!

=i&

=p2&

nod[i]<

2）

min=g[p1][i];

k1=p1;

k2=i;

if（g[p2][i]<

path[p2][i]==0&

p2!

=p1&

min=g[p2][i];

flag=p2;

if（flag）

path[flag][k2]=1;

path[k2][flag]=1;

nod[flag]++;

nod[k2]++;

p2=k2;

path[k1][k2]=1;

nod[k1]++;

p1=k2;

doublesum=0;

if（path[i][j]）

path[j][i]=0;

sum+=g[i][j]+16;

有边：

"

此处耗材长度为:

g[i][j]+16<

所求总长度为:

sum<

/*3.坐标图*/

cout<

----------------------------坐标图---------------------------"

endl<

structpointtemp;

//对数据的y值由大到小排序，以便构造坐标图

for（i=0;

n-1;

for（j=i+1;

if（p[i].y<

p[j].y）{

temp=p[i];

p[i]=p[j];

p[j]=temp;

}

inta=0;

//将a作为是否含有两点y值相同的数据和为小数的标志

for（i=0;

i++）{

for（j=i+1;

j<

{if（p[i].y==p[j].y）

a++;

//}

}

if（（p[i].x-int（p[i].x））!

=0||（p[i].y-int（p[i].y））!

=0）

{a++;

}

if（a!

=0）

{cout<

对不起！

无法显示坐标图!

注：

对含有两点在x相同情况下y值相同或点xy坐标含有小数的数据均不能构造坐标图"

原因：

在构造坐标图时因为点后面需空间附加其坐标，且所移步数只能为整数"

}else{//若符合坐标图显示条件则执行以下程序

intu=0;

intv=0;

*（X坐标轴）"

if（p[0].x!

=0）{cout<

*"

while（v!

=2*p[0].x）{cout<

"

v++;

*（"

p[0].x<

p[0].y<

）"

doubler=p[0].y;

for（i=1;

i++）{

intm=0;

intn=0;

while（m!

=（p[i-1].y-p[i].y）-1）{cout<

m++;

if（p[i].x!

while（n!

=2*p[i].x）{cout<

n++;

p[i].x<

p[i].y<

if（p[n-1].y!

=0）{

intt=0;

while（t!

=p[n-1].y-1）{cout<

t++;

*****************************（y坐标轴）"

O（0,0）"

-------------------------------------------------------------"

doubledst（structpointp,structpointq）//求连点距离函数实现

doubled=（p.x-q.x）*（p.x-q.x）+（p.y-q.y）*（p.y-q.y）;

returnsqrt（d）;