深度宽度优先搜索八数码.docx
《深度宽度优先搜索八数码.docx》由会员分享，可在线阅读，更多相关《深度宽度优先搜索八数码.docx（18页珍藏版）》请在冰豆网上搜索。
深度宽度优先搜索八数码
深度宽度优先搜索---八数码
————————————————————————————————作者:
————————————————————————————————日期：
八数码问题
具体思路:
宽度优先算法实现过程
（1）把起始节点放到OPEN表中;
（2）如果OPEN是个空表，则没有解,失败退出;否则继续；
（３）把第一个节点从OＰEＮ表中移除,并把它放入CLOＳＥD的扩展节点表中;
（4）扩展节点n。
如果没有后继节点，则转向
（2）
（5）把n的所有后继结点放到OPＥN表末端，并提供从这些后继结点回到n的指针;
（6）如果n的任意一个后继结点是目标节点，则找到一个解答，成功退出,否则转向
（2）。
开始
把S放入OPEN表
OPEN表为空
失败
把第一个节点n从把S放入OPEN表移除，放到CLOSED表中
移除
扩展n，把它的后继节点放入OPEN表的末端，提供回到n
的指针
是否任何节点为目标节点
成功
深度优先实现过程
（１）把起始节点Ｓ放入未扩展节点OPＥN表中。
如果此节点为一目标节点,则得到一个解;
（2）如果ＯPEN为一空表,则失败退出；
（3）把第一个节点从OPEN表移到CLＯSＥD表;
（4）如果节点n的深度等于最大深度,则转向
（2）；
（5）扩展节点n,产生其全部后裔,并把它们放入OＰEＮ表的前头。
如果没有后裔，则转向
（2）;
（6）如果后继结点中有任一个目标节点,则得到一个解，成功退出,否则转向
（2）。
开始
把S放入OPEN表
S是否为目标节点
成功
把第一个节点n从把S放入OPEN表移除，放到CLOSED表中
移除
节点n的深度是否等于最深界限
OPEN表为空
失败
扩展n，把它的后继放入OPEN表的前头，提供回到n的指针
是否有任何后继节点为目标节点
成功
方法一:
用C语言实现
#iｎｃludｅ
#incluｄe
#ｉｎclｕdｅ<ｓtdlib．h>
typedeflongUＩNT64；
tｙpeｄefstruct
{
ｃhａｒx;／/位置x和位置ｙ上的数字换位
cｈary;//其中x是0所在的位置
}EＰ_MＯVE;
#deｆｉneSIZＥ3／/8数码问题,理论上本程序也可解决15数码问题，
#ｄefinｅNUＭSIZE *SIＺE/／但ｍoｖｅ_gen需要做很多修改，输入初始和结束状态的部分和ｃhｅｃｋ_inｐuｔ也要修改
#defｉnｅＭAX_NＯDＥ100０000
#dｅfine MＡX＿DEP10０
＃defｉｎｅ XCＨG（a,b）｛a＝a ＋ b;b=a-b; a＝a－b；}
＃definｅ TRAＮS（a，ｂ）
／＊{lｏnｇiｉi;（ｂ）＝0; fｏｒ（ｉii=0;iiｉ #defｉne RTRＡNS（a,ｂ）\
{\
ｌｏng iｉi；＼
UINT64 ｔtt=（a）；\
ｆor（iｉi=NUM -1; iii>＝ 0；iiｉ－－） ＼
｛＼
b[ｉii]=ttt＆0ｘf; \
ｔtt>＞＝４;＼
}\
}//将一个６4位整数a转换为数组ｂ
//
typedefstructＥP＿ＮＯDＥ＿Tag
{UINＴ6４v; //保存状态，每个数字占4个二进制位,可解决１6数码问题
sｔrucｔEP_NODE_Tａg*prev；//父节点
ｓｔructEP_NODＥ_Tａg*sｍａll， ＊ｂig;
}EＰ＿NＯDE；
EＰ＿NＯDEｍ_ar[ＭＡＸ_NODE];
ＥP_NODE*m_rｏot；
longm＿depｔh；/／搜索深度
EP_ＮODE m_ouｔ［ＭAX_DEP];/／输出路径
//
loｎgｍove_gｅn（ＥP_NODE *noｄe，ＥP_MOVE *mｏve）
{lｏｎg ｐz;//０的位置
UINT6４t=０xf;
foｒ（pz=NUＭ - 1；ｐｚ＞＝０;pz－-）
{if（（ｎodｅ->ｖ&t）==0）
{ bｒeａk;/／找到０的位置
｝
t＜<=4;
}
switch（pz）
{casｅ0:
ｍove［0]．ｘ＝０;
movｅ[０].y=１;
mｏvｅ［1］.x=0;
move[１].ｙ=3;
reｔｕrn2;
case1:
move[０］．x=1;
move[0］．y=0;
move[1]．ｘ=１；
move[1].y=2;
mｏve[2］．x=1；
mｏve[2].y=4;
retuｒｎ3;
ｃasｅ２：
ｍoｖe[0]．x=２;
mｏve[0］.y=1；
ｍｏve［１］.x=２；
move[１].y=５；
return 2；
caｓｅ 3：
ｍove［0].ｘ=3；
ｍove[0].y=0;
ｍove[１］．x＝3;
moｖe[１].ｙ＝6；
movｅ[2].x＝3;
ｍovｅ［2］.y＝4;
return3;
ｃａse 4:
move[０]．x=４;
movｅ[0].ｙ=1;
ｍoｖｅ［1].x＝4;
ｍove[1］.y=3;
ｍove[2].x=4;
movｅ[2].y＝5;
ｍｏve［3].ｘ＝4;
move［3］．y＝７;
retuｒn４；
case5:
mｏｖe[0］.x=5;
ｍove[0].y=2;
ｍove［１].x=5；
mｏve［1].y＝4;
ｍoｖe[2］.x=5;
move[2]．y=8;
ｒetuｒｎ３;
case6：
mｏｖe［０]．x=６;
move[0].y=３;
moｖe［1］．x=６;
ｍovｅ［１].y=７;
ｒeｔuｒn ２；
case7:
mｏve［0].x＝7；
mｏvｅ[0].y＝6；
ｍｏｖe[１］.x=7；
ｍoｖe[1].y=４;
move[２]．x=7;
mｏve[2]．y＝8；
return3;
ｃasｅ8:
ｍｏｖe[0].x=8;
moｖｅ[0］．y＝5;
move[1］．x=8;
move[1].ｙ=７;
rｅtuｒｎ2;
}
ｒeｔurn0;
}
long moｖ（ＥP_NOＤE*n１， EＰ_MOＶE*mv,EP＿NＯDE *n2）
//走一步，返回走一步后的结果
{
chaｒss［NUM];
ＲTＲANＳ（n1-＞v,ss）;
XCHG（ss[mv－>x］,ss[mｖ－>y］）;
TRAＮS（ｓs,n2->v）;
ｒeturn 0；
}
longaｄｄ_node（EP＿NＯＤE*noｄｅ, longr）
｛
EP＿ＮODＥ*p=m_rooｔ;
EＰ_NＯDE*q;
whｉle（p）
{q=ｐ;
iｆ（p－>v==node->v） retuｒn０；
ｅlｓeｉf（nｏde－>ｖ>p－>v）p=p->biｇ;
ｅlseif（node-＞v<ｐ->v）p＝p－>smaｌl；
｝
ｍ_aｒ[r]．v＝node->v;
ｍ_ａr[r].ｐrev＝nodｅ-＞preｖ;
ｍ_ａr[r]．smａｌl=NＵLL;
m＿ar［ｒ].big＝NＵLL；
if（nｏｄe->v >q－>v）
{q->big=&m＿ar[r]；
}
else iｆ（node－>ｖ<ｑ－＞v）
{q－>ｓmall=＆ｍ_ar［r];
}
retuｒｎ 1；
}
/＊得到节点所在深度*/
longget_noｄe＿dｅpth（EP_NODE*node）
{long d=0;
while（ｎodｅ->ｐreｖ）
{ｄ++;
node=node->prev;
}
reｔurｎｄ；
}
／*返回值:
成功-返回搜索节点数,节点数不够－（-1），无解－（-2）＊／
long bｆs_ｓｅarｃh（chａr＊ｂeｇin，char*ｅｎｄ）
{long h=0,r=1， ｃ，i,ｊ;
EP_NＯDＥ l_ｅnd,node,＊ｐnode;
ＥP_MＯVE mv[4];//每个局面最多４种走法
TRＡNS（begｉn，m_aｒ[0].v）;
TＲＡＮS（enｄ,l_ｅnｄ.v）;
m＿ａr［０］.ｐｒev=NULＬ;
m_roｏt=m_ａｒ;
m_root－>ｓmall=ＮULＬ；
m_roｏｔ->big=ＮULL;
ｗhilｅ（（ｈ＜r） &&（r< MＡX_NＯDE－ 4））
｛c=moｖe_ｇｅｎ（&m_aｒ［ｈ],mv）;
ｆor（ｉ＝0； ｉ｛ｍov（&m_ar［h],&mv［i],＆nｏde）；
ｎｏｄｅ.pｒev= &m＿ａr[h]；
ｉf（ｎode.v== l_eｎd．v）
｛ pnode=＆ｎodｅ；
j=０;
while（pnodｅ－>prｅｖ）
｛m_ouｔ［ｊ]=*pnｏde;
ｊ++;
pｎode=pnｏdｅ-＞prev;
｝
m_depth＝j;
reｔuｒnr;
}
if（add_nｏde（&node,r））ｒ++;／/只能对历史节点中没有的新节点搜索,否则会出现环
｝
h++;
printf（"＼rSearcｈ...％9ｄ/%d@ %d",h,r,geｔ_ｎode_dｅｐtｈ（&m_ar［h]））；
}
iｆ（h==r）
{reｔurn-2； }
else
{retuｒｎ-1;}
}
lonｇcheck＿iｎｐut（chaｒ*s，ｃhａｒa， longr）
{ ｌonｇｉ；
ｆor（i＝0;i<ｒ； i++）
{ if（s［i］=＝ a - ０x30）retuｒn0；}
retｕrｎ1;
}
long chｅck＿possｉble（char*begｉn，chaｒ*end）
{cｈar fｓ；
lonｇf1=0,f2=0；
lonｇ i,j；
for（ｉ＝0; i {fs=0;
fｏｒ（j=0;j< i;j++）
｛
if（（begin[i]!
=0）&&（begin[j]!
= 0）&＆（begiｎ[j]}
ｆ1+=fｓ;
fｓ=0;
fｏｒ（j=０;j＜i；j＋+）
｛iｆ（（ｅnd[ｉ] !
＝0） ＆& （end[ｊ]!
=0） &&（eｎd[j] }
f2＋＝fs；
}
if（（f1&１）== （f２&1））reｔurｎ１;
else
reｔurｎ０;
｝
ｖoｉｄoutpuｔ（void）
｛ lonｇi, j， k;
ｃhaｒss[NUＭ];
fｏｒ（i=m_depth-1;ｉ>=0; i-－）
｛RTＲANS（ｍ_out[i]．v,ss）；
for（j=0;ｊ<ＳIＺE；j+＋）
{for（k=0； k< ＳIZE;k＋+）
{ｐrintf（"%２d",ss[ＳIZE＊ ｊ+k]）;
}
pｒinｔf（"\n"）；
}
pｒintf（"\n"）;
}
}
ｉntmaｉn（ｖoｉd）
{ char s１[NUM];
chａrｓ2[NUM]；
loｎg r;
char a;
prinｔｆ（＂请输入开始状态：
"）;
r=0；
while（ｒ <ＮUM）
{ a＝getchaｒ（）;
if（a＞=0x30&＆a <0x39 && check_iｎpuｔ（s1, a，r））
{s1[r+＋］＝a-０x30;
priｎtf（"%c",a）;
｝
｝
prinｔｆ（＂＼n请输入结束状态:
"）;
r=０;
ｗｈiｌｅ（r{ａ＝getchar（）;
ｉｆ（a>=0x3０&&ａ< 0ｘ39&＆cｈｅｃk_input（s2，ａ,r））
{ s2［ｒ+＋］=ａ-０ｘ30;
pｒinｔf（"%c",a）;
}
}
priｎtf（"\n"）；
iｆ（check_possible（s1,s2））
{r=bfs_search（s１， s2）；
prinｔf（"\n＂）；
ｉf（r>＝0）
{printｆ（＂查找深度=%d，所有的方式=%lｄ\n", m_depth， r）;
oｕtput（）;
｝
elseｉf（r ＝=-1）
｛prｉntf（"没有找到路径．\n"）;
}
ｅlseｉf（r==-2）
{priｎtｆ（"这种状态变换没有路径到达.\ｎ"）；
}
else
{pｒintｆ（＂不确定的错误．\n"）;
}
}
ｅlsｅ
{ prｉntf（"不允许这样移动!
\ｎ＂）;
}
reｔurn0；
}
方法二：
用ＭAＴLＡB实现
progｒam8ｎｏ_bfs; {八数码的宽度优先搜索算法}
Cｏnst
Dｉr：
array[1..4,1..2］oｆiｎtegｅｒ{四种移动方向，对应产生式规则}
=（（1,０）,（－1,0）,（0,1）,（0，－1））;
ｎ=10００0;
Type
T8no ＝aｒrａy[1..3,1..３］ｏfiｎteｇer;
ＴLiｓt=ｒecｏrd
Fathｅr :
iｎｔegｅr； {父指针｝
dｅｐ:
bytｅ; {深度}
Ｘ0,Y0：
ｂyｔe； {０的位置}
Sｔate:
T８no; ｛棋盘状态}
eｎd;
Ｖar
Ｓouｒce,Tarｇｅt:
T８no;
Lisｔ :
array[0.．1000０]ｏfTList;{综合数据库 }
Closed,open,Best:
iｎtｅｇer {Best表示最优移动次数}
Anｓwer：
inteｇer; ｛记录解}
Fｏund:
Boｏlean； {解标志}
prｏcedｕrｅ GetＩnfo; ｛读入初始和目标节点｝
vａr i，j:
inteｇｅr;
beｇiｎ
for ｉ:
=１ ｔo３do
forj:
=1ｔo3ｄo reaｄ（Sourcｅ[i，ｊ]）;
ｆｏｒi：
＝1to 3do
fｏｒj:
＝1 to ３ｄｏrｅaｄ（Target[i,j]）;
eｎd;
pｒｏcｅduｒｅ Iｎitialiｚｅ; {初始化}
vａrｘ，ｙ:
ｉntｅｇer;
begiｎ
Foｕｎd:
＝fａlｓｅ;
Ｃlｏsed:
＝0;open:
=1；
ｗitｈLisｔ[1] ｄｏbegin
Ｓtatｅ:
=Ｓource;dｅp:
=0；Ｆatheｒ：
＝0；
Ｆorx:
＝1ｔo 3ｄo
For y：
=1to 3dｏ
ifSｔate［x，y]=0tｈen Ｂeｇinｘ０:
＝x;y0:
=y;Enｄ；
enｄ;
end；
FunctｉonＳaｍe（A,Ｂ :
Ｔ8nｏ）：
Ｂoｏlean； {判断A，B状态是否相等}
Var i,j:
integer；
Ｂeｇin
Same:
=falｓｅ;
Ｆori:
=1to 3dofｏrｊ:
=１to3dｏ iｆＡ［ｉ,j]＜>Ｂ[ｉ，j]thｅnexit;
Saｍｅ：
=trｕｅ;
End;
Funｃtiｏｎｎｏt_Appear（new：
tＬiｓｔ）：
booｌeaｎ;{判断neｗ是否在List中出现｝
varｉ：
ｉnｔｅger；
ｂｅgin
not_Ａｐpear:
＝false;
forｉ:
=1toopeｎdoifSame（new.Ｓtate,Lisｔ[i］.Statｅ）tｈｅnexit;
not_Appｅaｒ:
=true;
enｄ;
prｏceｄuｒeMoｖe（n :
tList;ｄ:
ｉntegeｒ;varoｋ :
ｂoolean；varnew：
tＬiｓｔ）;
{将第d条规则作用于ｎ得到ｎew，OＫ是ｎew是否可行的标志}
var ｘ,y :
ｉnｔeger;
ｂegin
X :
=n.x0＋Dir[ｄ,1];
Y:
=n.y0 +Dｉr[d,2］;
｛判断new的可行性}
if not （（X > 0）anｄ （ X <4 ）and（Ｙ> 0）ａｎd（Y＜ 4 ））thenbegｉnok:
=false;ｅxit end;
OＫ:
=truｅ；
nｅｗ．State：
=n.Ｓtａte； {neｗ=Eｘｐand（n，d）}
new.Statｅ［Ｘ,Y]:
=0;
new．Stａtｅ[n.x0,ｎ．y0]：
=n.Ｓtate[Ｘ,Y]；
ｎew.Ｘ0:
＝X；nｅw.Y0:
＝Y;
end;
pｒoｃedureAｄｄ（ｎew:
tＬｉｓｔ）; {插入节点new}
begin
ifnｏt_Appear（neｗ）tｈｅn Bｅgiｎ {如果new没有在Lｉst出现}
Inc（oｐen）; {new加入opeｎ表}
Lｉst［open] :
=new;
ｅnd;
ｅｎd;
pｒｏcedｕreExpａnd（Index:
ｉnteger;vａrn:
tLiｓt）;｛扩展ｎ的子节点}
vａri ：
intｅｇer;
nｅw：
tLｉｓｔ;
OK:
ｂooleaｎ;
Beｇin
ifＳaｍｅ（n.State, Taｒgｅt） tｈenｂegiｎ {如果找到解}
Foｕｎd：
= ｔrue;
Beｓｔ：
=n．Deｐ;
Aｎswｅr:
=Inｄeｘ；
Exｉt;
enｄ;
Fｏrｉ:
＝1 ｔo4dobegin ｛依次使用4条规则｝
Mｏve（ｎ,i,OK,nｅｗ）;
ifnoｔok thencｏntｉnｕe;
nｅw．Fａther：
=Indｅx；
neｗ.Deｐ :
＝n.dｅｐ+ 1;
Ａdｄ（neｗ）;
ｅnd;
end;
ｐｒoｃｅｄure GeｔOuｔＩnfo; {输出｝
pｒｏｃeｄureＯutｌoｏk（Ｉndex：
inｔeｇer）； {递归输出每一个解｝
var i,j:
inteｇｅr；
begiｎ
iｆIndex＝０tｈeｎeｘiｔ;
Ouｔlook（List[Ｉndex］.Fathｅr）;
wiｔhList[Iｎdex]do
forｉ：
=1tｏ３doｂegin
forj:
＝1to 3ｄowriｔe（Statｅ［i,j］,''）;
ｗriteln；
ｅnd;
writeln;
end;
ｂegｉn
Ｗｒiteln（'Totaｌ ＝＇,Besｔ）;
Ｏuｔｌoｏｋ（Ａnｓwer）；
end;
procedｕrｅＭａin; {搜索主过程｝
begin
Repeａｔ
Inｃ（Closeｄ）；
Expand（Closeｄ，List[Closed］）； {扩展Ｃlosed}
Uｎｔiｌ（Clｏｓed＞=open）orFoｕnd;
ｉfFoｕnd tｈenＧetOutIｎfo {存在解｝
ｅｌse Writeln（＇noａnswer'）; {无解}
ｅｎd;
Begｉn
Ａssｉgn（Input,'iｎput.tｘt'）;ReSｅt（Inｐut）;
Ａssｉgｎ（Oｕｔｐut,'Oｕtｐuｔ.txt'）;RｅWrite（Output）;
GeｔIｎｆｏ;
Initiaｌｉze;
Main;
Ｃlose（Inpuｔ）；Close（Oｕtput）;
End.
五、实验结果
六、实验总结
通过实验问题的求解过程就是搜索的过程，采用适合的搜索算法是关键的,因为对求解过程的效率有很大的影响,包括各种规则、过程和算法等推理技术。
八数码问题中,将牌的移动来描述规则，是一种相对较简单的方法。
用广度优先算法实现八数码问题，其实是一种比较费劲的方式;然而深度优先将是一个很好的方法,利用深度优先不但减少了程序实现的时间，是一种不错的方式。
但最好的方式是启发式搜索方式实现，在很大程度上相对于前两种方式是一种非常好的实现方式，不但节省了时间，也节省了空间。
通过这次试验使我对搜索算法有了一定的了解，并对实现这个问题的执行过程有了更一步的认识。
也通过它解决了八数码问题,但在实际的过程中还存在很多问题，也看了一些辅助书籍,以后还要加强学习，加强理论与实际的练习。
总之,这次试验使我受益匪浅。
升级会员 