人工智能A星算法Word文档下载推荐.docx
《人工智能A星算法Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《人工智能A星算法Word文档下载推荐.docx（13页珍藏版）》请在冰豆网上搜索。
7）从M的每一个不在G中的成员建立一个指向n的指针（例如，既不在OPEN中，也不在CLOSED中）。
把M1的这些成员加到OPEN中。
对M的每一个已在OPEN中或CLOSED中的成员m，如果到目前为止找到的到达m的最好路径通过n，就把它的指针指向n。
对已在CLOSED中的M的每一个成员，重定向它在G中的每一个后继，以使它们顺着到目前为止发现的最好路径指向它们的祖先。
8）按递增f*值，重排OPEN（相同最小f*值可根据搜索树中的最深节点来解决）。
9）返回第3步。
在第7步中，如果搜索过程发现一条路径到达一个节点的代价比现存的路径代价低，就要重定向指向该节点的指针。
已经在CLOSED中的节点子孙的重定向保存了后面的搜索结果，但是可能需要指数级的计算代价。
实验步骤
算法流程图
程序代码
#include<
iostream>
ctime>
vector>
usingnamespacestd;
constintROW=3;
//行数
constintCOL=3;
//列数
constintMAXDISTANCE=10000;
//最多可以有的表的数目
constintMAXNUM=10000;
typedefstruct_Node{
intdigit[ROW][COL];
intdist;
//一个表和目的表的距离
intdep;
//t深度
intindex;
//节点的位置
}Node;
Nodesrc,dest;
//父节表目的表
vector<
Node>
node_v;
//存储节点
boolisEmptyOfOPEN（）//open表是否为空
{
for（inti=0;
i<
node_v.size（）;
i++）{
if（node_v[i].dist!
=MAXNUM）
returnfalse;
}
returntrue;
}
boolisEqual（intindex,intdigit[][COL]）//判断这个最优的节点是否和目的节点一样
ROW;
i++）
for（intj=0;
j<
COL;
j++）{
if（node_v[index].digit[i][j]!
=digit[i][j]）
ostream&
operator<
<
（ostream&
os,Node&
node）
j++）
os<
node.digit[i][j]<
'
;
endl;
returnos;
voidPrintSteps（intindex,vector<
&
rstep_v）//输出每一个遍历的节点深度遍历
rstep_v.push_back（node_v[index]）;
index=node_v[index].index;
while（index!
=0）
{
for（inti=rstep_v.size（）-1;
i>
=0;
i--）//输出每一步的探索过程
cout<
"
Step"
<
rstep_v.size（）-i
endl<
rstep_v[i]<
voidSwap（int&
a,int&
b）
intt;
t=a;
a=b;
b=t;
voidAssign（Node&
node,intindex）
node.digit[i][j]=node_v[index].digit[i][j];
intGetMinNode（）//找到最小的节点的位置即最优节点
intdist=MAXNUM;
intloc;
//thelocationofminimizenode
i++）
if（node_v[i].dist==MAXNUM）
continue;
elseif（（node_v[i].dist+node_v[i].dep）<
dist）{
loc=i;
dist=node_v[i].dist+node_v[i].dep;
returnloc;
boolisExpandable（Node&
node）
if（isEqual（i,node.digit））
intDistance（Node&
node,intdigit[][COL]）
intdistance=0;
boolflag=false;
for（inti=0;
j++）
for（intk=0;
k<
k++）{
for（intl=0;
l<
l++）{
if（node.digit[i][j]==digit[k][l]）{
distance+=abs（i-k）+abs（j-l）;
flag=true;
break;
else
flag=false;
if（flag）
returndistance;
intMinDistance（inta,intb）
return（a<
b?
a:
b）;
voidProcessNode（intindex）
intx,y;
boolflag;
if（node_v[index].digit[i][j]==0）
x=i;
y=j;
elseflag=false;
if（flag）
Nodenode_up;
Assign（node_up,index）;
//向上扩展的节点
intdist_up=MAXDISTANCE;
if（x>
0）
Swap（node_up.digit[x][y],node_up.digit[x-1][y]）;
if（isExpandable（node_up））
dist_up=Distance（node_up,dest.digit）;
node_up.index=index;
node_up.dist=dist_up;
node_up.dep=node_v[index].dep+1;
node_v.push_back（node_up）;
Nodenode_down;
Assign（node_down,index）;
//向下扩展的节点
intdist_down=MAXDISTANCE;
if（x<
2）
Swap（node_down.digit[x][y],node_down.digit[x+1][y]）;
if（isExpandable（node_down））
dist_down=Distance（node_down,dest.digit）;
node_down.index=index;
node_down.dist=dist_down;
node_down.dep=node_v[index].dep+1;
node_v.push_back（node_down）;
Nodenode_left;
Assign（node_left,index）;
//向左扩展的节点
intdist_left=MAXDISTANCE;
if（y>
Swap（node_left.digit[x][y],node_left.digit[x][y-1]）;
if（isExpandable（node_left））
dist_left=Distance（node_left,dest.digit）;
node_left.index=index;
node_left.dist=dist_left;
node_left.dep=node_v[index].dep+1;
node_v.push_back（node_left）;
Nodenode_right;
Assign（node_right,index）;
//向右扩展的节点
intdist_right=MAXDISTANCE;
if（y<
Swap（node_right.digit[x][y],node_right.digit[x][y+1]）;
if（isExpandable（node_right））
dist_right=Distance（node_right,dest.digit）;
node_right.index=index;
node_right.dist=dist_right;
node_right.dep=node_v[index].dep+1;
node_v.push_back（node_right）;
node_v[index].dist=MAXNUM;
intmain（）//主函数
intnumber;
Inputsource:
"
i++）//输入初始的表
cin>
>
number;
src.digit[i][j]=number;
src.index=0;
src.dep=1;
Inputdestination:
//输入目的表
for（intm=0;
m<
m++）
for（intn=0;
n<
n++）{
dest.digit[m][n]=number;
node_v.push_back（src）;
//在容器的尾部加一个数据
Search..."
clock_tstart=clock（）;
while
（1）
if（isEmptyOfOPEN（））
Cann'
tsolvethisstatement!
return-1;
//thelocationoftheminimizenode最优节点的位置
loc=GetMinNode（）;
if（isEqual（loc,dest.digit））
vector<
rstep_v;
Source:
src<
PrintSteps（loc,rstep_v）;
Successful!
Using"
（clock（）-start）/CLOCKS_PER_SEC
seconds."
ProcessNode（loc）;
return0;
程序运行效果图
2
8
3
1
6
4
7
5
（初始状态）
（结束状态）
个人实验小结
通过本实验，我熟悉启发式搜索的定义、估价函数和算法过程，并利用A*算法求解了8数码难题，理解了求解流程和搜索顺序。
实验过程中巩固了所学的知识，通过实验也提高了自己的编程和思维能力，收获很多。
欢迎您的下载，
资料仅供参考！
致力为企业和个人提供合同协议，策划案计划书，学习资料等等
打造全网一站式需求
升级会员 