计算机网络布线问题.docx

计算机网络布线问题.docx

《计算机网络布线问题.docx》由会员分享，可在线阅读，更多相关《计算机网络布线问题.docx（34页珍藏版）》请在冰豆网上搜索。

计算机网络布线问题

编号：

数学与计算科学学院

创新性实验结题报告书

实验题目：

计算机网络布线问题

实验成绩（教师填写）：

学院：

数学与计算科学学院

专业：

信息与计算科学

姓名学号：

张稳华0800710128

曾强0800710127

何明注0800710111

指导教师：

唐敏

2011年04月15日

一、实验目的及主要创新性点：

实验目的：

1编制计算机程序解决问题；

2算法设计问题（理论问题：

最短路径）结合实际的网络应用；

3解决该问题要有创新思想，积极思考解决问题的各种方法，试图和实际的网络中的应用相结合。

创新：

遗传算法是一种基于概率意义的随机搜索算法,它的思想是构造一个问题的解的初代种群，经过选择，交叉和变异产生新的最优解集种群。

遗传算法的特点具有自组织、自适应和自学习性,遗传算法提供了一种求解复杂系统优化问题的通用框，在工程设计、演化硬件电路设计以及人工智能等方面应用前景广阔。

二、实验要求：

1提出解决该问题的各种方法；

2编制计算机程序解决问题；

3要与实际的网络应用结合起来。

三、实验内容

计算机网络要求网络中的计算机被连接起来。

本问题考虑一个“线性”的网络，在这一网络中计算机被连接到一起，并且除了首尾的两台计算机只分别连接着一台计算机外，其他任意一台计算机恰连接着两台计算机。

图1中用黑点表示计算机，它们的位置用直角坐标表示（相对于一个在图中未画出的坐标系）。

网络中连接的计算机之间的距离单位为英尺。

由于很多原因。

我们希望使用的电缆长度应尽可能地短，你的问题是去决定计算机应如何被连接以使你所用的电缆长度最短。

在设计方案施工时，电缆将埋在地下，因此连接两台计算机所要用的电缆总长度等于计算机之间的距离加上额外的16英尺电缆，以从地下连接到计算机，并为施工留一些余量。

图2给出了上图中计算机的最优连接方案，这样一个方案所有电缆的总长度是（4+16）+（5+16）+（5.38+16）+（11.18+16）=90.01英尺。

图1

图2

四、实验解决方法

通过实验内容，我们知道，本次实验要满足两个条件：

一是所用的电缆长度最短；二是除了首尾的两台计算机只分别连接着一台计算机外，其他任意一台计算机恰连接着两台计算机。

我们想到了几种解决方法：

1、基于全排列的穷举法

穷举法也叫枚举法或列举法。

通常对于一些要求得到精确结果而所求结果又不大的时候可用此法,具体的做法就是将所有可能的情况一一举出。

穷举法就是举例,用无穷个数字进行实验,直到达到得出规律或者结果时候为止。

此题因点数限制在8个，具有可行性。

2、把其看作是一个图的遍历，每个点只访问一次，有且仅有n-1条边。

3、最小生成树，考虑到最小生成树一个点可访问多于二个点，因此在构造最小生成树时，需要多加一个限制条件，以控制每个点被访问一次。

4、此问题也可看作成旅行商问题，因旅行商问题，从起点出发最后又回到起点，此问题不需要回到起点，因此也可以用旅行商问题方面的方法进行求解。

也可以看成找到一个欧拉回路，再去掉回路中最长的一条边。

5、递归算法

递归算法：

是一种直接或者间接地调用自身的算法。

在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。

在使用递归策略时，必须有一个明确的递归结束条件，而本题中这个条件就是最短路径。

6、遗传算法

遗传算法（GeneticAlgorithm）是模拟达尔文的遗传选择和自然淘汰的生物进化过程的计算模型，是一种通过模拟自然进化过程搜索最优解的方法。

本次实验，我们小组将采用基于全排列的穷举法和遗传算法来求解问题。

五、实验原理

基于全排列的穷举法。

穷举法肯定能找出最短路径，不过怎样进行穷举呢？

本文采用基于全排列的穷举。

从n个不同元素中任取m（m≤n）个元素，按照一定的顺序排列起来，叫做从n个不同元素中取出m个元素的一个排列。

当m＝n时所有的排列情况叫全排列。

只要全排列的算法可行，那么问题可得到求解。

本文采用递归算法进行全排列，再在全排列中求解最短路径。

便可得到精确解。

遗传算法是从代表问题可能潜在的解集的一个种群（population）开始的，而一个种群则由经过基因（gene）编码的一定数目的个体（individual）组成。

每个个体实际上是染色体（chromosome）带有特征的实体。

染色体作为遗传物质的主要载体，即多个基因的集合，其内部表现（即基因型）是某种基因组合，它决定了个体的形状的外部表现。

因此，在一开始需要实现从表现型到基因型的映射即编码工作。

由于仿照基因编码的工作很复杂，我们往往进行简化，如二进制编码，初代种群产生之后，按照适者生存和优胜劣汰的原理，逐代（generation）演化产生出越来越好的近似解，在每一代，根据问题域中个体的适应度（fitness）大小选择（selection）个体，并借助于自然遗传学遗传算子（geneticoperators）进行组合交叉（crossover）和变异（mutation），产生出代表新的解集的种群。

这个过程将导致种群像自然进化一样的后生代种群比前代更加适应于环境，末代种群中的最优个体经过解码（decoding），可以作为问题近似最优解。

遗传算法的特点：

遗传算法是一类可用于复杂系统优化的具有鲁棒性的搜索算法，与传统的优化算法相比，主要有以下特点：

1、遗传算法以决策变量的编码作为运算对象。

传统的优化算法往往直接决策变量的实际植本身，而遗传算法处理决策变量的某种编码形式，使得我们可以借鉴生物学中的染色体和基因的概念，可以模仿自然界生物的遗传和进化机理，也使得我们能够方便的应用遗传操作算子。

2、遗传算法直接以适应度作为搜索信息，无需导数等其它辅助信息。

3、遗传算法使用多个点的搜索信息，具有隐含并行性。

4、遗传算法使用概率搜索技术，而非确定性规则。

六、实验步骤

1开发环境配置

安装MicrosoftVisualc++6.0

2程序流程图

图3遗传算法程序流程图

步1在论域空间U上定义一个适应度函数f（x），给定种群规模N，交叉率Pc和变异率Pm，代数T；

步2随机产生U中的N个染色体s1,s2,…,sN，组成初始种群S={s1,s2,…,sN}，置代数计数器t=1；

步3计算S中每个染色体的适应度f（）；

步4若终止条件满足，则取S中适应度最大的染色体作为所求结果，算法结束。

步5按选择概率P（xi）所决定的选中机会，每次从S中随机选定1个染色体并将其复制，共做N次，然后将复制所得的N个染色体组成群体S1；

步6按交叉率Pc所决定的参加交叉的染色体数c，从S1中随机确定c个染色体，配对进行交叉操作，并用产生的新染色体代替原染色体，得群体S2；

步7按变异率Pm所决定的变异次数m，从S2中随机确定m个染色体，分别进行变异操作，并用产生的新染色体代替原染色体，得群体S3；

步8将群体S3作为新一代种群，即用S3代替S，t=t+1，转步3；

3详细设计

程序设计：

程序的设计用的是MicrosoftVisualc++6.0编写的。

基于全排列的穷举法:

#include

#include

#include

usingnamespacestd;

//定义文件输入，用于测试时输入方便

//ifstreamfin（"in.txt"）;

//#definecinfin

#defineN8//计算机最大的台数

intm=0;//递归时用到，设为全局

intsum;//当前计算机总的台数

inta[40321][N+1];//用于存储全排列

/*inta[][]=newint[40321][N+1];*/

//存储坐标

structpoint

{

intx,y;

}pointer[N+1];

//对几个点进行全排列,采用递归算法

voidperm（int*num,inti）

{

intj,k,tmp;

if（i

{

for（j=i;j<=sum;j++）

{

tmp=num[j];

for（k=j;k>i;k--）

num[k]=num[k-1];

num[i]=tmp;

perm（num,i+1）;

for（k=i;k

num[k]=num[k+1];

num[j]=tmp;

}

}

else{//此次排列

for（j=1;j<=sum;j++）

{

a[m][j]=num[j];

/*cout<

}

m++;

/*cout<

}

}

//计算两点之间的距离;多次调用，设为内联函数，提高效率

inlinefloatDistance（structpointx,structpointy）

{

//当两点相同时，返回0

if（x.x==y.x&&x.y==y.y）

return0;

else

returnsqrtf（pow（x.x-y.x,2）+pow（x.y-y.y,2））;

}

voidinput（）

{

m=0;//记录每次全排列，开始时需置0

/*cin>>sum;*/

//intnum[N+1];

inti;

int*num=newint[sum+1];

floatshortdistance[40321]={0};

floatreslut=1172;

for（i=1;i<=sum;i++）

num[i]=i;

perm（num,1）;

for（i=1;i<=sum;i++）

{

cin>>pointer[i].x>>pointer[i].y;

}

//for（i=1;i<=sum;i++）

//{

//cout<

//}

delete（num）;//释放空间

}

voidsearch（）

{

inti,j;

floatdistance[N+1][N+1]={0};

floatshortdistance[40321]={0};

floatreslut=1172;//8个点最长距离

intrecord=1;

//距离邻接矩阵

for（i=1;i<=sum;i++）

{

for（j=1;j<=sum;j++）

{

distance[i][j]=Distance（pointer[i],pointer[j]）;

/*cout<

}

/*cout<

}

//由sum计算循环次数

intcount=1;

for（i=1;i<=sum;i++）

{

count*=i;

}

/*cout<<"count:

"<

for（i=0;i

{

for（j=1;j

{

shortdistance[i]+=distance[a[i][j]][a[i][j+1]]+16;

}

//cout<

if（shortdistance[i]<=reslut）

{

reslut=shortdistance[i];

//最小距离的排列

//for（j=1;j<=sum;j++）

//{

//cout<

//}

//cout<

record=i;

}

}

//保留两位小数输出

cout.setf（ios:

:

fixed）;

cout.precision

（2）;

//最小距离的排列输出

for（j=sum;j>1;j--）

{

//cout<

cout<<"Cablerequirementtoconnect";

cout<<"（"<

cout<<"to"<<"（"<

cout<<"is"<<16+Distance（pointer[a[record][j]],pointer[a[record][j-1]]）<<"feet."<

}

cout<<"Numberoffeetofcablerequiredis";

cout<

}

intmain（）

{

intn=0;

while（cin>>sum&&sum!

=0）

{

input（）;

cout<<"*******************************************************************"<

cout<<"Network#"<<++n<

search（）;

}

return0;

}

遗传算法的代码如下:

#include

#include

#include

#include

#include

#include

#include

usingnamespacestd;

//ifstreamfin（"in.txt"）;

//ofstreamfout（"out.txt"）;

//#definecinfin

//#definecoutfout

//变异概率

#defineMUTATION_RATE0.2

//杂交概率

#defineCROSSOVER_RATE0.75

//基因组数目

#definePOP_SIZE40

//为2的倍数

#defineNUM_BEST_TO_ADD2

//产生随机数

inlineintRandInt（intx,inty）

{

returnrand（）%（y-x+1）+x;

}

inlinedoubleRandFloat（）

{

return（rand（））/（RAND_MAX+1.0）;

}

//计算机坐标结构

structCoOrd

{

floatx,y;

CoOrd（）{};

CoOrd（floata,floatb）:

x（a）,y（b）{};

};

//基因组结构

structSGenome

{

//连接计算机间的路径（基因组）

vectorvecPC;

//适应分数

doubledFitness;

//构造函数

SGenome（）:

dFitness（0）{}

SGenome（intnc）:

dFitness（0）

{

vecPC=GrabPermutation（nc）;

}

//创建计算机间随机的一条路径

vectorGrabPermutation（int&limit）;

//在GrabPermutation函数中使用

boolTestNumber（constvector&vec,constint&number）;

};

//遗传算法类

classCgaTSP

{

private:

//计算机坐标向量

vectorm_vecPCCoOrds;

vectorm_vecPopulation;

vectorm_savevecPC;

doublem_dMutationRate;

doublem_dCrossoverRate;

//整个种子群体的总适应性分

doublem_dTotalFitness;

//在此之前找到的最短路径

doublem_dShortestRoute;

//把所有代中的最短路径保存起来

doublem_saveShortestRoute;

//最长路径

doublem_dLongestRoute;

//种子群中的基因组数目

intm_iPopSize;

//染色体数目

intm_iChromoLength;

//新一代中适应分最高的成员

intm_iFittestGenome;

//表明已经到了那一代

intm_iGeneration;

//交换变异

voidMutateEM（vector&chromo）;

//部分匹配杂交

voidCrossoverPMX（constvector&mum,constvector&dad,

vector&baby1,vector&baby2）;

SGenome&RouletteWheelSelection（）;

//计算计算机之间连接路径的长度

doubleGetTourLength（constvector&route）;

voidCalculatePopulationsFitness（）;

voidCalculateBestWorstAvTot（）;

voidReset（）;

voidCreateStartingPopulation（）;

//计算两个计算之间的长度

doubleCalculateA_to_B（constCoOrd&PC1,constCoOrd&PC2）;

//建立坐标

voidCreateCoOrd（）;

public:

//构造函数

CgaTSP（doublemut_rat,

doublecross_rat,

intpop_size,

intNumPC

）:

m_dMutationRate（mut_rat）,

m_dCrossoverRate（cross_rat）,

m_iPopSize（pop_size）,

m_iFittestGenome（0）,

m_iGeneration（0）,

m_dShortestRoute（999999999）,

m_saveShortestRoute（999999999）,

m_dLongestRoute（0）,

m_iChromoLength（NumPC）

{

//建立坐标

CreateCoOrd（）;

//清除基因组生成新的基因组

CreateStartingPopulation（）;

}

~CgaTSP（）

{

}

//把所有的遗传算法的步骤进行合并到一个函数

voidEpoch（）;

voidShow（）;

};

/***********************************************************************************************/

//随机生成一个基因并返回

vectorSGenome:

:

GrabPermutation（int&limit）

{

vectorvecPerm;

for（inti=0;i

{

//0到limint-1为计算机的序号

intNextPossibleNumber=RandInt（0,limit-1）;

//向量中存在随见生成的序号就在生成一次

while（TestNumber（vecPerm,NextPossibleNumber））

{

NextPossibleNumber=RandInt（0,limit-1）;

}

//把新生成的序号放进向量

vecPerm.push_back（NextPossibleNumber）;

}

//返回基因

returnvecPerm;

}

//测试number是否已经存在向量中

boolSGenome:

:

TestNumber（constvector&vec,constint&number）

{

for（inti=0;i

{

if（vec[i]==number）

{

returntrue;

}

}returnfalse;

}

//计算路径长度和适应性分

voidCgaTSP:

:

CalculatePopulationsFitness（）

{

//对于每组基因计算路径长度

for（inti=0;i

{

//计算计算机间路径的总长度

doubleTourLength=GetTourLength（m_vecPopulation[i].vecPC）;

m_vecPopulation[i].dFitness=TourLength;

if（TourLength

{

m_dShortestRoute=TourLength;

//代表适应性分最高的成员

m_iFittestGenom