用盲目搜索技术解决八数码问题Word下载.docx

用盲目搜索技术解决八数码问题Word下载.docx

《用盲目搜索技术解决八数码问题Word下载.docx》由会员分享，可在线阅读，更多相关《用盲目搜索技术解决八数码问题Word下载.docx（10页珍藏版）》请在冰豆网上搜索。

#include<

iostream>

ctime>

vector>

usingnamespacestd;

constintROW=3;

//行数

constintCOL=3;

//列数

constintMAXDISTANCE=10000;

//最多可以有的表的数目

constintMAXNUM=10000;

typedefstruct_Node{

intdigit[ROW][COL];

intdist;

//distancebetweenonestateandthedestination

一个表和目的表的距离

intdep;

//thedepthofnode深度

//Sothecommentfunction=dist+dep.估价函数值

intindex;

//pointtothelocationofparent父节点的位置

}Node;

Nodesrc,dest;

//父节表目的表

vector<

Node>

node_v;

//storethenodes存储节点

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]）

returnfalse;

}

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

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&

for（inti=0;

i<

node_v.size（）;

i++）{

if（isEqual（i,node.digit））

intDistance（Node&

node,intdigit[][COL]）

intdistance=0;

boolflag=false;

for（inti=0;

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）

break;

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;