深度宽度优先搜索八数码Word文档格式.docx
《深度宽度优先搜索八数码Word文档格式.docx》由会员分享，可在线阅读，更多相关《深度宽度优先搜索八数码Word文档格式.docx（18页珍藏版）》请在冰豆网上搜索。
（ｂ）＝0;
fｏｒ（ｉii=0;
iiｉ <
NUM;
iｉi＋+） （b）=（（b）＜<
4）+ a[ｉii];
}*///将数组a转换为一个64位的整数ｂ
#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；
ｃ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；
ｉ<
c;
i++）
｛ｍ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 <
NUＭ;
i＋+）
{fs=0;
fｏｒ（j=0;
j<
i;
j++）
if（（begin[i]!
=0）&
（begin[j]!
= 0）&
＆（begiｎ[j]<
begin[i]））fs++;
ｆ1+=fｓ;
fｓ=0;
fｏｒ（j=０;
j＜i；
j＋+）
｛iｆ（（ｅnd[ｉ] !
＝0） ＆&
（end[ｊ]!
=0） &
（eｎd[j] <
eｎｄ[i］））ｆs++;
f2＋＝fs；
if（（f1&
１）== （f２&
1））reｔurｎ１;
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（"
）;
ｉ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<
NＵM）
{ａ＝getchar（）;
ｉｆ（a>
=0x3０&
ａ<
0ｘ39&
＆cｈｅｃk_input（s2，ａ,r））
{ s2［ｒ+＋］=ａ-０ｘ30;
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ｆ（"
这种状态变换没有路径到达.\ｎ"
{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]）;
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ｗ）;
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'
{无解}
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.
五、实验结果
六、实验总结
通过实验问题的求解过程就是搜索的过程，采用适合的搜索算法是关键的,因为对求解过程的效率有很大的影响,包括各种规则、过程和算法等推理技术。
八数码问题中,将牌的移动来描述规则，是一种相对较简单的方法。
用广度优先算法实现八数码问题，其实是一种比较费劲的方式;
然而深度优先将是一个很好的方法,利用深度优先不但减少了程序实现的时间，是一种不错的方式。
但最好的方式是启发式搜索方式实现，在很大程度上相对于前两种方式是一种非常好的实现方式，不但节省了时间，也节省了空间。
通过这次试验使我对搜索算法有了一定的了解，并对实现这个问题的执行过程有了更一步的认识。
也通过它解决了八数码问题,但在实际的过程中还存在很多问题，也看了一些辅助书籍,以后还要加强学习，加强理论与实际的练习。
总之,这次试验使我受益匪浅。
升级会员 