人工智能课程设计报告八皇后问题与罗马尼亚问题.docx

人工智能课程设计报告八皇后问题与罗马尼亚问题.docx

《人工智能课程设计报告八皇后问题与罗马尼亚问题.docx》由会员分享，可在线阅读，更多相关《人工智能课程设计报告八皇后问题与罗马尼亚问题.docx（34页珍藏版）》请在冰豆网上搜索。

人工智能课程设计报告八皇后问题与罗马尼亚问题

人工智能课程设计报告（八皇后问题与罗马尼亚问题）

人工智能课程设计报告

1（N皇后问题…………………………………………………………1

需求分析，设计…………………………………………………1

设计表示…………………………………………………………1

运行结果…………………………………………………………2

用户手册即测试数据……………………………………………2

结论………………………………………………………………5

主要算法代码……………………………………………………52罗马尼亚问题…………………………………………………………9

需求分析，设计…………………………………………………9

设计表示，详细设计……………………………………………9

用户手册…………………………………………………………11

运行结果…………………………………………………………11

主要算法代码……………………………………………………12

3.实习心得………………………………………………………………………21

1N皇后问题

1（问题描述、需求分析

在N*N的棋盘上分布N个皇后，其中N个皇后不能在同一行同一列，也

不能出现在同一对角线上，此时N个皇后不会相互攻击。

程序需能手动输入皇后个数，并分别采用回溯法、爬山法、遗传法得出

皇后的分布情况，输出皇后的位置即棋盘。

2（设计思想

2.1形式化

N个皇后的位置可用一个N维数组表示，如921543……，意思是第一

个皇后在第一列的第9行。

2.2程序模块

CreatIndividual（）函数用于产生一组表示皇后不在同一行也不再

同一列的的一位数组，即产生一组互不相等的0~N之间的整数，便于快

速求解。

IsLegal（）函数用于判断新放置的皇后是否合法，在回溯法中用到。

AttackQueenNum（）用于计算整个棋盘的攻击皇后个数，相当于一个

评价函数，在爬山法和遗传法中用到;

Find（）回溯法求解函数

ClimbHill（）爬山法求解函数;

GA（）遗传算法求解函数;

（1）函数调用关系图如下:

（2）函数接口规格说明:

下图中的箭头指向表示为被指向函数所用

IsLegal（）CreatIndividual（）

AttackQueenNum（）Find（）

GA（）

ClimbHill（）

主函数

2.3详细设计

a:

CreatIndividual（int*A,intQueenNum）:

以当时时间为种子循环产生

随机数，为了使得产生的随机数都不想等，设计集合S[N]并初始化为0，

表示还没有产生一个皇后，当产生的皇后不在S[N]中即S[N]～=1时将

2

S[n]置为1，接着产生下一个皇后，如此循环便产生一组互不相等的值。

b:

IsLegal（int*A,intt）此函数用于判断第t列的皇后是否合法，即有

没有皇后在同一行、同一列，同一对角线上，并返回true或者false。

c:

AttackQueenNum（int*A,intQueenNum）循环调用IsLegal（）函数对攻

击数进行累加并返回其值，此函数作为棋盘的评价函数。

d:

Find（int*A,intk,intQueenNum,longbeginTime）回溯法求解，因为

回溯法的每一层都是for循环，所以不能单纯的用break语句进行控制，

因为即使当前层循环停止了，程序还会继续执行上一层的循环，所以将

起始时间作为参数进行传递，以便求出算法执行时间，然后用exit（0）

语句终止程序，所以要将回溯法放在其它两个算法的后面执行。

e:

ClimbHill（int*A,intQueenNum）:

由于在产生一个棋盘个体的时候所

有的皇后就不在同一行同一列，所以在爬山法中只对棋盘的列进行交

换，这样即使再怎么交换所有的皇后还是不在同一行同一列，但在交换

的时候需要调用AttackQueenNum（）函数进行棋盘的评价，如果交换前

的攻击数大于交换后的攻击数则进行交换，否则与下一列进行交换比

较，如此循环直到找出解。

f:

GA（）

3（用户手册

运行程序，输入皇后个数N，各种算法得到的皇后分布情况、耗时自动显示;4（测试数据及测试结果

测试4，20,30,50皇后，测试结果如下:

分别

程序运行结果:

4皇后运行结果

20皇后运行结果如下

3

4

30皇后运行结果如下:

5

50皇后运行结果如下

由于50皇后的棋盘稍大，这里只给出运行时间

结论:

根据输入皇后个数递增的运行结果可以看出爬山法的速度是相当快的，在皇后个数比较少时回溯法的速度要快于遗传算法，而当皇后个数比较多时，回溯法的深度搜索明显慢于遗传算法。

主要算法程序代码:

1:

boolIsLegal（int*A,intt）//判断第t列的皇后位置是否合法{

inti;

for（i=0;i

{

if（A[i]==A[t]）

returnfalse;

6

}

if（t>0&&abs（A[t-1]-A[t]）==1）

//然后再判断是否与相邻前一列皇后发生冲突

returnfalse;

returntrue;

}

2:

voidCreatIndividual（int*A,intQueenNum）

{

inti,x;//在产生随机数时使用

int*s=newint[QueenNum];//集合，用于产生一组皇后位置

for（i=0;i

s[i]=0;

srand（（unsigned）time（NULL））;//种子

A[0]=rand（）%QueenNum;//第一列的皇后可以没有限制的产生，所以先产生

s[A[0]]=1;

for（i=1;i

{

do

{

x=rand（）%QueenNum;

}while（s[x]==1）;

//s[x]==1表示此位置已有皇后，则重新产生新的位置

A[i]=x;

s[A[i]]=1;

}

}

3:

voidFind（int*A,intk,intQueenNum,longbeginTime）

{

inti,j;

if（k==QueenNum）

{

for（i=0;i

{

printf（""）;

for（j=0;j

{

if（A[j]==i）printf（"#"）;

elseprintf（"O"）;

}

printf（"\n"）;

}

longendTime=clock（）;

//获得结束时间（endTime-beginTime）<10000，单位为毫秒

printf（"回溯法%d皇后耗时:

%dms\n",QueenNum,endTime-beginTime）;

7

exit（0）;

}

else

{

for（i=0;i

{

A[k]=i;//对A[k]从0开始进行赋值，下面再判断所赋的值是否合法，合法的话进行下一列皇后位置的赋值

if（IsLegal（A,k））

Find（A,k+1,QueenNum,beginTime）;

//当循环结束时仍然找不到则返回一层，A[k]的层数加1

}

}

}

4:

intAttackQueenNum（int*A,intQueenNum）

{

inti,CountAttack=0;

if（abs（A[0]-A[1]）==1）//判断第一列

CountAttack++;

for（i=1;i

{

if（abs（A[i]-A[i-1]）==1）//与前一列是否冲突

CountAttack++;

if（abs（A[i]-A[i+1]）==1）//与后一列是否冲突

CountAttack++;

}

if（abs（A[QueenNum-2]-A[QueenNum-1]）==1）//判断最后一列

CountAttack++;

returnCountAttack;

}

5:

voidClimbHill（int*A,intQueenNum）{

inti,j,temp,Mark,Count,CountAttack;//Mark用于标记交换的位置

intMinCountAttack;//在选取移动方案时使用

int*SaveTry=newint[QueenNum];//存储临时方案，用于比较

CreatIndividual（A,QueenNum）;

CountAttack=AttackQueenNum（A,QueenNum）;

MinCountAttack=CountAttack;

for（i=0;i

SaveTry[i]=A[i];

while（CountAttack!

=0）

{

for（i=0;i

=0;i++）

{

8

Mark=-1;

MinCountAttack=AttackQueenNum（SaveTry,QueenNum）;

//在每一列与其他列交换之前MinCountAttack都等于当前的Try的攻击数

for（j=0;j

=0;j++）

{

if（i!

=j）//只与其他列进行交换

{

temp=SaveTry[j];

SaveTry[j]=SaveTry[i];

SaveTry[i]=temp;

Count=AttackQueenNum（SaveTry,QueenNum）;

if（Count==0）

{

MinCountAttack=Count;//即为0

Mark=j;//记录交换列的位置

break;//如果攻击数位0直接跳出循环

}

if（Count

{

MinCountAttack=Count;

Mark=j;//记录交换列的位置

}

temp=SaveTry[j];//再将刚刚交换的位置复原，用于与下

一列进行比较，交换两次即达到交换的效果

SaveTry[j]=SaveTry[i];

SaveTry[i]=temp;

}

}

if（MinCountAttack==0）break;

if（Mark!

=-1）

{

temp=SaveTry[Mark];//再将刚刚交换的位置复原，用于与下一

列进行比较，交换两次即达到交换的效果

SaveTry[Mark]=SaveTry[i];

SaveTry[i]=temp;

}

}

CountAttack=AttackQueenNum（SaveTry,QueenNum）;

}

for（i=0;i

A[i]=SaveTry[i];//存储存储最终结果

}

9

2罗马尼亚问题

1（需求分析:

从文件中读取图和启发函数，分别用Dijkstra、深度优先、广度优先、贪婪算法、A*算法得到从起始点Arad到目标点Bucharest的一条路径，即为罗马尼亚问题的一个解，在求解的过程中记录扩展节点的个数（用于比较几种算法的优劣），记录每种算法得到的解，即输出每种解得到的条路径。

2（设计:

2.1设计思想

对于图的存储采用邻接矩阵进行存储，因为此图节点与边比较多（若比较少则采用邻接表结构，此时效率比较高），采用堆栈和队列等进行路径的存储，并且在某条路径走到最大深度都没有发现目标节点时具有返回上一节点的能力（好处:

在某条路上找不到时可以进入相邻的一条路径，并不是单纯的返回:

索索失败），为了不重复访问同一个节点（此时路径会出现环，导致程序循环执行）利用集合的思想，即将访问过的节点状态置为1没有访问过的置为0，以此来避免路径出现环。

2.2设计表示

（1）函数调用关系图

ReadGraphFile（）

Greedy_Searth（）

BF_Searth（）

DF_Searth（）ReadHFile（）

Dijkstra（）主函数A_Searth（）

2.3详细设计

10

a:

Dijkstra（）设置集合数组Gather[MaxVertices]，按照路径长度递增的顺序逐步产生最短路径，并将起始点到其他节点的距离存放到数组distance[]中，将到每一个节点的最短路径的前一节点存至path[]数组中，从起始节点Arad开始，将其状态标为1，重复执行如下步骤N-1次，直至所有节点的状态都为1.

1）在所有不在集合的顶点中选取选取distance[i]最小的一个顶点，设置为

第u个顶点;

2）将选出的终结点序号U并入集合中，即其状态改为1;

3）以u作为新考虑的中间点，修改不在集合中的个顶点的distance[j]值，

如果distance[u]+G.edge[u,j]

G.edge[u,j]，同时记下此路径，path[j]=u;

在主函数中利用堆栈和path[]数组将起始节点到目标节点的路径找出来（因为寻找路径时是从目标点向前倒推寻找的，所以先将路径入栈，再出栈得到的既是从起始点到目标点的一条路径）。

b:

DF_Searth（）设置集合数组Gather[MaxVertices]，采用堆栈寻找路径;首先将起始节点入栈，然后执行如下循环:

1）读取栈顶元素，获得栈顶元素的一个邻接点（此节点的状态需是0，即未

访问过），在获得邻接顶点的过程中如果发现目标顶点则进栈，退出循环;2）如果此节点未访问过则进栈，并将其状态标为1;

3）如果找不到邻接点则出栈，执行

（1）;

在执行循环的过程中对扩展的节点个数进行计数，并将堆栈中的路径出栈到数组，在主函数中进行输出。

c:

BF_Searth（）设置集合数组Gather[MaxVertices]，采用队列寻找路径;首先将起始节点入队列，然后执行如下循环:

1）出队列，并将出队列的节点入栈（用于保存路径）;

2）循环获取此节点的邻接顶点（未访问过的，即状态为0的节点）并入队列，

状态标为1，在寻找邻接点的过程中如果发现目标节点则退出循环;

3）将每一次出队列的顶点都进栈保存（用于输出路径）

然后执行寻找路径部分:

此处再定义一个堆栈，首先将目标点进栈，设此栈为栈2，先前存储出队列元素的栈设为栈1:

1）栈2出栈;

2）栈1循环出栈，如果出栈的顶点状态为1并且与当前顶点不在图的同一行，

即不相邻，那么由栈1出栈的顶点即为栈2出栈顶点的父节点，将此节点

入栈2，执行

（1）;

最后将栈2中的所有节点出栈即为宽度优先寻找到的一条路径，同样在寻找的过程中记录扩展节点的个数;

d:

Greedy_Searth（）设置集合数组Gather[MaxVertices]，采用堆栈，首先将起始节点入栈，执行如下循环:

1）读出栈顶元素（只读，并不进行出栈操作）;

2）循环获取此元素的邻接顶点（即其所有的还未访问过的孩子），利用排序

找到启发函数值最小的孩子结点，将此孩子节点入栈，状态标为1，

执行

（1）;

3）如果读出的栈顶元素以找不到邻接顶点即孩子，说明此条路径已经走到最

大深度处，则出栈（即返回上一层），此时执行

（1），因为只对入栈的元

素状态值为1，所以返回上一层的时候寻找出所有的邻接顶点，并找出最

11

小值，此时的最小值是次小值（因为最小值那条路不通），这样程序便进

入下一条路径的寻找;

e:

A_Searth（）设置集合数组Gather[MaxVertices]，采用堆栈，首先将起始节点入

栈，执行如下循环:

1）读取栈顶元素，获取此节点的所有邻接顶点（即所有孩子），选取实际路

程g（N）与启发函数值最小的节点入栈，将其状态标为1，在此过程中如果

发现目标顶点则循环结束;

2）如果此条路已走到最大深度处则出栈，寻找下一条路径，执行

（1）;

在此函数中定义了一个20*3的数组GHF[MaxVertices][3]用于比较

f（N）=g（N）+h（N）（作业的表相似，执行过程相同）;

f:

ReadGraphFile（）与ReadHFile（）完成文件的读操作，利用fgetc（fp）函数进行一

位一位的读，并将读取的数据转换为整数形式进行存储，以供于其他算法的

使用，在循环读取文件的过程中注意文件尾的处理。

3（用户手册

直接运行程序即可得到Dijkstra、深度优先、广度优先、贪婪算法、A*算法得

到的解，即根据相应的算法的到从起始节点到目标节点的一条路径。

4（整体运行结果如下:

5（主要算法代码如下:

12

//Dijkstra算法

voidDijkstra（AdjMGraphG,intv0,intdistance[],intpath[]）

{

intn=G.vertices.size;

int*s=（int*）malloc（sizeof（int）*n）;//集合

intminDis,i,j,u;

//初始化

for（i=0;i

{

distance[i]=G.edge[v0][i];

s[i]=0;

if（i!

=v0&&distance[i]

elsepath[i]=-1;

}

s[v0]=1;

for（i=1;i

{

minDis=MaxWeight;

for（j=0;j

if（s[j]==0&&distance[j]

{

u=j;

minDis=distance[j];

}

if（minDis==MaxWeight）return;

s[u]=1;

for（j=0;j

if（s[j]==0&&G.edge[u][j]

distance[u]+G.edge[u][j]

{

distance[j]=distance[u]+G.edge[u][j];

path[j]=u;

}

}

}

//深度优先搜索

voidDF_Searth（AdjMGraphG,intv0,intvg,intpath[],int*Expand,int

*AnswerWay）

{

inti,x,SumExpand=0;

intVertex;//用于寻找目标节点

intGather[MaxVertices];//集合

SeqStackS;

13

StackInitiate（&S）;

for（i=0;i

Gather[i]=0;

StackPush（&S,v0）;//首先将起始节点入栈

SumExpand++;

Gather[v0]=1;

while

（1）

{

StackTop（S,&x）;

Vertex=GetFirstVex（G,x）;//获取第一个临接点

while（Gather[Vertex]==1）

{

Vertex=GetNextVex（G,x,Vertex）;

}

while（Vertex==-1）//此时未找到下一个临接点

{

StackPop（&S,&x）;

StackTop（S,&x）;

Vertex=GetFirstVex（G,x）;

while（Gather[Vertex]==1）

{

Vertex=GetNextVex（G,x,Vertex）;

}

}

StackPush（&S,Vertex）;

SumExpand++;

Gather[Vertex]=1;

//同一条路径上那个不允许出现相同的节点，防止转圈

if（Vertex==vg）break;

}

*Expand=SumExpand;

*AnswerWay=S.top;

if（S.top==0）

printf（"深度优先搜索失败!

!

!

"）;

else

{

while（StackNotEmpty（S））

{

StackTop（S,&x）;

path[S.top-1]=x;

StackPop（&S,&x）;

}

}

14

}

//宽度优先搜索

voidBF_Searth（AdjMGraphG,intv0,intvg,intpath[],int*Expand,int

*AnswerWay）

{

inti,x,y,SumExpand=0;

intVertex;//用于寻找目标节点

intGather[MaxVertices];//集合

SeqStackSaveQ,LineSave;//SaveQ将出队列的节点全部进栈,LineSave用于保存路径,

StackInitiate（&SaveQ）;

StackInitiate（&LineSave）;

SeqCQueueQ;

QueueInitiate（&Q）;

for（i=0;i

Gather[i]=0;

QueueAppend（&Q,v0）;//首先将起始节点入队列

SumExpand++;

Gather[v0]=1;

while

（1）

{

QueueDelete（&Q,&x）;

StackPush（&SaveQ,x）;//将每一个出队列的结点进行保存

Vertex=GetFirstVex（G,x）;//获取第一个临接点

if（Vertex==vg）break;//此时找到目标节点

if（Vertex==-1）

{

printf（"宽度优先搜索失败!

!

!

"）;

return;

}

while（Vertex!

=-1）//将x的所有邻接顶点入队列

{

if（Gather[Vertex]==0）//表示还未扩展

{

QueueAppend（&Q,Vertex）;

Su