人工智能导论实验报告.docx

人工智能导论实验报告.docx

《人工智能导论实验报告.docx》由会员分享，可在线阅读，更多相关《人工智能导论实验报告.docx（25页珍藏版）》请在冰豆网上搜索。

人工智能导论实验报告

院系：

计算机科学学院

专业：

计算机科学与技术

年级：

2012级

课程名称：

人工智能

学号：

2012213567

姓名：

王亚戈

指导教师:

尹帆

2014年6月24日

年级

2012级

学号

2012213567

专业

班级

3班

王亚戈

计算机科学与技术

姓名

实验

八数码问题

实验

设计型

综合型

创新式

名称

种类

实

验

目

的

实验题目：

或

要

求

#include

#include

#include

#defineOverflow1

#defineN3

intgoal[N][N]={1,2,3,8,0,4,7,6,5};

intzero[2],NodeQTY=0;

int*z=zero;//记录0的地址，zero[0]:

r行；zero[1]:

c列

typedefintPiece;

structChessboard{//棋盘信息

Piecepos[N][N];//记录每个数码a的地址r行c列

实intd,f,move;//d:

深度；f:

启示函数值；move:

父节点搬动到该节点的方式

验};

原structLNode{

理Chessboardboard;

（LNode*parent,*next;

算boolflag;

法};

流typedefLNode*List;

程int*Findzero（LNode*&Node）

）{

inti,j,zr[2];

int*z=zr;

for（i=0;i

for（j=0;j

if（Node->board.pos[i][j]==0）{

zr[0]=i+1;

zr[1]=j+1;

break;

}

}

}

returnz;

}

intWrong（LNode*Node）

{

intw=0,i,j;

for（i=0;i

for（j=0;j

if（Node->board.pos[i][j]!

=goal[i][j]&&Node->board.pos[i][j]!

=0）

w++;

}

}

returnw;

}

intpick（LNode*Node）

{

intw=0,i,j,ii,jj;

for（i=0;i

for（j=0;j

if（Node->board.pos[i][j]!

=goal[i][j]&&Node->board.pos[i][j]!

=0）{

for（ii=0;ii

for（jj=0;jj

if（Node->board.pos[i][j]==goal[ii][jj]）{

w=w+abs（ii-i）+abs（jj-j）;

break;

}

}

}

}

returnw;

}

LNode*extend（LNode*Node,intdepth,intzero[2],intmoveflag,intChoose）

{

LNode*NewNode=newLNode;

for（inti=0;i

for（intj=0;j

NewNode->board.pos[i][j]=Node->board.pos[i][j];

}

}

switch（moveflag）

{

case1:

//向左移，不能够出界：

zero[1]>=2

NewNode->board.pos[zero[0]-1][zero[1]-1]=NewNode->board.pos[zero[0]-1][zero[1]-2

];

NewNode->board.pos[zero[0]-1][zero[1]-2]=0;

break;

case2:

//向右移，不能够出界：

zero[1]<=2

NewNode->board.pos[zero[0]-1][zero[1]-1]=NewNode->board.pos[zero[0]-1][zero[1]];NewNode->board.pos[zero[0]-1][zero[1]]=0;

break;

case3:

//向上移，不能够出界：

zero[0]>=2

NewNode->board.pos[zero[0]-1][zero[1]-1]=NewNode->board.pos[zero[0]-2][zero[1]-1

];

NewNode->board.pos[zero[0]-2][zero[1]-1]=0;

break;

case4:

//向下移，不能够出界：

zero[0]<=2

NewNode->board.pos[zero[0]-1][zero[1]-1]=NewNode->board.pos[zero[0]][zero[1]-1];NewNode->board.pos[zero[0]][zero[1]-1]=0;

break;

}

NewNode->board.d=depth+1;

switch（Choose）{

case1:

NewNode->board.f=NewNode->board.d+Wrong（NewNode）;break;case2:

NewNode->board.f=NewNode->board.d+pick（NewNode）;break;

}

NewNode->board.move=moveflag;

NewNode->parent=Node;

NodeQTY++;

returnNewNode;

}

voidInitList（LNode*&Open,LNode*&Close）

{

Open=（List）malloc（sizeof（LNode））;

Close=（List）malloc（sizeof（LNode））;

if（!

Open&&!

Close）

exit（Overflow）;

Open->next=NULL;

Close->next=NULL;

}

intListInsert（List&L,LNode*NewNode）

{

Listp=L;

while（p->next）{

p=p->next;

}

NewNode->next=p->next;

p->next=NewNode;

returntrue;

}

LNode*Getminf（List&L）

{

Listp=L,q=L->next,r=L,min;

min=q;//p,q搜寻f最小值的指针，r指向表L中min前一个元素if（!

q）

returnNULL;

while（q）

{

if（min->board.f>q->board.f）{

r=p;

min=q;

}

p=q;

q=q->next;

}

r->next=min->next;

min->next=NULL;

returnmin;

}

intmain（）

{

inti,j,choose;

ListOpen,Close;

LNode*Best,*current;

LNode*Start=newLNode;

printf（"\t\t\t八数码问题求解\n"）;

printf（"\n请输入初始状态：

"）;

for（i=0;i

for（j=0;j

scanf（"%d",&（Start->board.pos[i][j]））;

}

}

printf（"（注:

Theflagofmovement--1:

左移;2:

右移;3:

上移;4:

下移）\n"）;printf（"初始棋盘状态：

\n"）;

for（i=0;i

for（j=0;j

printf（"|%d",Start->board.pos[i][j]）;

}

printf（"|\n"）;

}

InitList（Open,Close）;

printf（"请选择（1:

A算法;2:

A*算法）:

"）;

scanf（"%d",&choose）;

Start->board.d=0;

switch（choose）{

case1:

Start->board.f=Start->board.d+Wrong（Start）;break;

case2:

Start->board.f=Start->board.d+pick（Start）;break;

}//Start->board.f=0+Wrong（Start）;Start->board.move=0;Start->parent=NULL;Start->next=NULL;Start->flag=1;

ListInsert（Open,Start）;//将S加入到Open表中

while（Open->next）{

Best=Getminf（Open）;

ListInsert（Close,Best）;

if（!

（Best->board.f-Best->board.d））{

printf（"$$$******有解！

******$$$\n"）;

break;

}

z=Findzero（Best）;

zero[0]=*（z+0）;zero[1]=*（z+1）;

if（zero[1]>=N-1&&Best->board.move!

=2）

ListInsert（Open,extend（Best,Best->board.d,zero,1,choose））;

if（zero[1]<=N-1&&Best->board.move!

=1）

ListInsert（Open,extend（Best,Best->board.d,zero,2,choose））;

if（zero[0]>=N-1&&Best->board.move!

=4）

ListInsert（Open,extend（Best,Best->board.d,zero,3,choose））;

if（zero[0]<=N-1&&Best->board.move!

=3）

ListInsert（Open,extend（Best,Best->board.d,zero,4,choose））;

}

printf（"本算法搜寻图中总合扩展的节点数为：

%d\n",NodeQTY）;

printf（"\t最正确路径以下所示：

\n"）;

if（Open->next）

{

while（Best->parent）{

Best->flag=1;

Best=Best->parent;

}

Listp=Close->next,q=Close->next;

if（p==Start）q=p->next;

elseexit

（1）;

intStep=0;

while（p&&q）//在Close表中依标志找到路径

{

if（q->flag==1&&q->parent==p）{

printf（"Step%d:

0moveasthe%d-flagof

movement.\n",++Step,q->board.move）;

for（i=0;i

for（j=0;j

printf（"|%d",q->board.pos[i][j]）;

}

printf（"|\n"）;

}

p=q;//记住父节点

}

q=q->next;

}

printf（"到达目标状态！

\n"）;

}

elseprintf（"该问题无法求解！

\n"）;

}

组

内

分

工

（

可

选

）

实验截图

1、A算法：

实

验

结

果

分

析

及

心

得

体

会

2、A*算法：

心得领悟

经过本次试验，我对启示式搜寻有了更加深入的认识。

在实验中，经过对两种启示式搜寻所扩在的节点数来看，

p（n）

看来比

（n）

更加有

效，能在复杂情况下求得更加优秀的解，防备不用要的节点的扩展。

但是对于估价函数

*

索问题，如国际象棋问题，他就显得较简单。

所以，要更好地定义一个估价函数还有待

深入谈论。

在搜寻最正确扩展路径的过程中我发现，最正确扩展路基上的节点均在CLOSED利用标志flag，以及它们之间的父子关系，我很简单的就找到了扩展路径，防备了再用一个路径指针path来找到路径，这样节约了储藏空间，更利于搜寻。

表中，

经过实验结果来看，这两个函数都是可采纳的，尽管

（n）

存在不用要的扩展。

成

绩

评

定

教师签字：

2014年月日

备注：

源代码附后，源代码要求有说明说明

年级

2012级

班级

学号

2012213567

专业

3班

王亚戈

计算机科学与技术

姓名

实验

水壶问题

实验

设计型

综合型

创新式

名称

种类

实

验

目

的

或

要

求

#include

#include

#include

#include

#include

#defineM1000

intvis[M+5][M+5];

intaNum,bNum,cNum;

实

structNode

/*状态节点*/

{

验

intx;

原

inty;

理

intstep;

（

};

算

法

structparent/*

记忆表*/

流

{

程

intpx;

）

intpy;

}prev[M+5][M+5];

voiddfs（intx,inty）

{

if（prev[x][y].px+prev[x][y].py!

=0）

{

dfs（prev[x][y].px,prev[x][y].py）;

}/*EndofIf*/

intprex=prev[x][y].px;

intprey=prev[x][y].py;

/*Fill（A）*/

if（prex!

=aNum&&x==aNum&&y==prey）

{

printf（"Fill（A）\n"）;

return;

}

/*Fill（B）*/

if（prey!

=bNum&&y==bNum&&x==prex）

{

printf（"Fill（B）\n"）;

return;

}

/*Empty（A）*/

if（prex!

=0&&x==0&&y==prey）

{

printf（"Empty（A）\n"）;

return;

}

/*Empty（B）*/

if（prey!

=0&&y==0&&x==prex）

{

printf（"Empty（B）\n"）;

return;

}

/*Pour（A,B）orPour（B,A）*/

if（prex+prey==x+y）

{/*倒水前后总水量不变*/if（x==0||y==bNum）

{

printf（"Pour（A,B）\n"）;

}

else

{

printf（"Pour（B,A）\n"）;

}

return;

}

}/*dfs*/

voidBFS（）

{

intIsSolve=0;

/*

问题求解标志，初始时问题未被求解*/

intrear=-1;

/*

队列尾指针*/

intfront=-1;

/*

队首指针*/

Nodecur,next;

Nodequeue[M+10]={0};

cur.x=0;

/*

当前水壶A

状态*/

cur.y=0;

/*

当前水壶B

状态*/

cur.step=0;

/*

记录当前步数

*/

queue[++rear]=cur;/*

初始状态入队*/

vis[0][0]=1;

/*初始状态设为已被接见*/

while（front!

=rear）

{/*队列不为空时循环*/

cur=queue[++front];

if（cur.x==cNum||cur.y==cNum）

{

IsSolve=1;

printf（"TotalStep:

%d\n",cur.step）;

dfs（cur.x,cur.y）;/*dfs回溯打印可行方案*/

break;

}/*EndofIf*/

/*operationstepaddone*/

next.step=cur.step+1;

/*OP1:

Fill（A）*/

next.x=aNum;

next.y=cur.y;

if（!

vis[next.x][next.y]）

{

vis[next.x][next.y]=1;

prev[next.x][next.y].px=cur.x;/*记忆表的实现*/

prev[next.x][next.y].py=cur.y;

queue[++rear]=next;

}

/*OP2:

Fill（B）*/

next.x=cur.x;

next.y=bNum;

if（!

vis[next.x][next.y]）

{

vis[next.x][next.y]=1;

prev[next.x][next.y].px=cur.x;

prev[next.x][next.y].py=cur.y;

queue[++rear]=next;

}

/*OP3:

Empty（A）*/

next.x=0;

next.y=cur.y;

if（!

vis[next.x][next.y]）

{

vis[next.x][next.y]=1;

prev[next.x][next.y].px=cur.x;

prev[next.x][next.y].py=cur.y;

queue[++rear]=next;

}

/*OP4:

Empty（B）*/

next.x=cur.x;

next.y=0;

if（!

vis[next.x][next.y]）

{

vis[next.x][next.y]=1;

prev[next.x][next.y].px=cur.x;

prev[next.x][next.y].py=cur.y;

queue[++rear]=next;

}

/*OP5:

Pour（A,B）*/

next.y=（cur.x+cur.y）

（cur.x+cur.y）:

bNum;

next.x=cur.x-（next.y-cur.y）;

if（!

vis[next.x][next.y]）

{

vis[next.x][next.y]=1;

prev[next.x][next.y].px=cur.x;

prev[next.x][next.y].py=cur.y;

queue[++rear]=next;

}

/*OP6:

Pour（B,A）*/

next.x=（cur.x+cur.y）

（cur.x+cur.y）:

aNum;

next.y=cur.y-（next.x-cur.x）;

if（!

vis[next.x][next.y]）

{

vis[next.x][next.y]=1;

prev[next.x][next.y].px=cur.x;

prev[next.x][next.y].py=cur.y;

queue[++rear]=next;

}

}/*EndofWhile*/

if（!

IsSolve）

{

printf（"NoSolution.\n"）;

}

}/*BFS*/

intmain（）

{

while（~scanf（"%d%d%d",&aNum,&bNum,&cNum））

{

/*Resetthearray*/

memset（vis,0,sizeof（vis））;

memset（prev,0,sizeof（prev））;

BFS（）;/*利用广度优先搜搜寻出所有可能解*/

}/*EndofWhile*/

return0;

}

组

内

分

工

（

可

选

）

实验截图

实

验

结

果

分

析

及

心

得

体

会

心得领悟

本实验利用广度优先搜搜寻出所有可能解，进一步加深了我对该算法的理解。

成

绩

评教师签字：

定

2014年月日

备注：

源代码附后，源代码要求有说明说明

年级

2012级

学号

2012213567

专业

班级

3班

王亚戈