人工智能导论状态空间搜索实验八数码问题求解文档格式.docx

人工智能导论状态空间搜索实验八数码问题求解文档格式.docx

《人工智能导论状态空间搜索实验八数码问题求解文档格式.docx》由会员分享，可在线阅读，更多相关《人工智能导论状态空间搜索实验八数码问题求解文档格式.docx（15页珍藏版）》请在冰豆网上搜索。

8

3

1

6

4

7

5

（a）初始状态（b）目标状态

图1八数码问题示意图

请任选一种盲目搜索算法（广度优先搜索或深度优先搜索）或任选一种启发式搜索方法（全局择优搜索，加权状态图搜索，A算法或A*算法）编程求解八数码问题（初始状态任选）。

选择一个初始状态，画出搜索树，填写相应的OPEN表和CLOSED表，给出解路径，对实验结果进行分析总结，得出结论。

实验报告内容格式要求：

XXXXXXXXXXXX（中文：

宋体，小四；

英文：

Times

五、实验结果及分析

采用深度优先搜索方式并简化搜索

六、结论

Open表close表

120

23401

2456013目标完成

七、源程序及注释

#include 

<

stdio.h>

}//设计了搜索深度范围，防止队列内存越界

stdlib.h>

6、运行结果

time.h>

#define 

N 

3 

//数码组大小 

Max_Step 

50 

//最大搜索深度 

MAX 

typedef 

struct 

node//八数码结构体 

{ 

int 

form[N][N];

//数码组 

evalue;

//评估值 

udirect;

//所屏蔽方向，防止往回推到上已状态，1上2下3左4右 

node 

*parent;

//父节点 

/////////打印数码组 

void 

Print（Graph 

*The_graph） 

i,j;

if（The_graph==NULL） 

printf（"

图为空\n"

）;

else 

---------------------\n"

for（i=0;

i<

N;

i++） 

|\t"

for（j=0;

j<

j++） 

%d\t"

The_graph->

form[i][j]）;

//遍历打印 

} 

\t|\n"

|\t\t\t差距:

%d\t|\n"

evalue）;

//差距显示 

/////////评价函数 

Evaluate（Graph 

*The_graph,Graph 

*End_graph） 

valute=0;

//差距数 

if（The_graph->

form[i][j]!

=End_graph->

form[i][j]） 

valute++;

The_graph->

evalue=valute;

return 

valute;

/////////移动数码组 

Graph 

*Move（Graph 

*The_graph,int 

Direct,int 

CreatNew_graph） 

*New_graph;

// 

HasGetBlank=0;

//是否获取空格位置 

AbleMove=1;

//是否可移动 

i,j,t_i,t_j,x,y;

i++）//获取空格坐标i,j 

form[i][j]==0） 

HasGetBlank=1;

break;

if（HasGetBlank==1） 

//printf（"

空格位置:

%d,%d\n"

i,j）;

t_i=i;

t_j=j;

//移动空格 

switch（Direct） 

case 

1:

//上 

t_i--;

if（t_i<

0） 

AbleMove=0;

2:

//下 

t_i++;

if（t_i>

=N） 

3:

//左 

t_j--;

if（t_j<

4:

//右 

t_j++;

if（t_j>

if（AbleMove==0）//不能移动则返回原节点 

The_graph;

if（CreatNew_graph==1） 

New_graph=（Graph 

*）malloc（sizeof（Graph））;

//生成节点 

for（x=0;

x<

x++） 

for（y=0;

y<

y++） 

New_graph->

form[x][y]=The_graph->

form[x][y];

//复制数码组 

New_graph=The_graph;

//移动后 

form[i][j]=New_graph->

form[t_i][t_j];

form[t_i][t_j]=0;

移动产生的新图:

\n"

//Print（New_graph）;

New_graph;

/////////搜索函数 

*Search（Graph 

*Begin,Graph 

*End） 

*g1,*g2,*g;

Step=0;

//深度 

Direct=0;

//方向 

i;

front,rear;

front=rear=-1;

//队列初始化 

g=NULL;

rear++;

//入队 

Qu[rear]=Begin;

while（rear!

=front）//队列不空 

front++;

//出队 

g1=Qu[front];

开始第%d个图:

front）;

//Print（g1）;

for（i=1;

=4;

i++）//分别从四个方向推导出新子节点 

Direct=i;

if（Direct==g1->

udirect）//跳过屏蔽方向 

continue;

g2=Move（g1, 

Direct, 

1）;

//移动数码组 

if（g2!

=g1）//数码组是否可以移动 

//可以移动 

Evaluate（g2, 

End）;

//评价新的节点 

开始产生的第%d个图:

i）;

//Print（g2）;

if（g2->

evalue<

=g1->

evalue+1） 

//是优越节点 

g2->

parent=g1;

switch（Direct）//设置屏蔽方向，防止往回推 

udirect=2;

udirect=1;

udirect=4;

udirect=3;

Qu[rear]=g2;

//存储节点到待处理队列 

evalue==0）//为0则搜索完成 

g=g2;

//i=5;

free（g2）;

//抛弃劣质节点 

g2=NULL;

if（g!

=NULL）//为0则搜索完成 

if（g->

evalue==0） 

Step++;

//统计深度 

if（Step>

Max_Step） 

g;

/////////初始化一个八数码结构体 

*CR_BeginGraph（Graph 

srand（（unsigned）time（0））;

M=10;

//随机移动步数 

Direct;

i,x,y;

M;

Direct=rand（）%4+1;

//产生1－4随机数 

Direct:

%d\n"

Direct）;

New_graph=Move（New_graph, 

0）;

evalue=0;

udirect=0;

parent=NULL;

main 

（int 

argc, 

const 

char 

* 

argv[]） 

insert 

code 

here... 

/* 

Begin_graph={ 

{{2,8,3},{1,6,4},{0,7,5}},0,0,NULL 

};

{{2,8,3},{1,0,4},{7,6,5}},0,0,NULL 

{{2,0,1},{4,6,5},{3,7,8}},0,0,NULL 

*/ 

//目标数码组 

End_graph={ 

{{1,2,3},{8,0,4},{7,6,5}},0,0,NULL 

//初始数码组 

*Begin_graph;

Begin_graph=CR_BeginGraph（&

End_graph）;

//随机产生初始数码组 

Evaluate（Begin_graph, 

&

//对初始的数码组评价 

初始数码组:

Print（Begin_graph）;

目标数码组:

Print（&

*G,*P;

top=-1;

//图搜索 

G=Search（Begin_graph, 

//打印 

if（G） 

//把路径倒序 

P=G;

//压栈 

while（P!

=NULL） 

top++;

St[top]=P;

P=P->

parent;

搜索结果>

>

//弹栈打印 

while（top>

-1） 

P=St[top];

top--;

Print（P）;

完成>

搜索不到结果，深度为%d\n"

Max_Step）;

//设计搜索深度范围主要是防止队列内存越界 

0;