数据结构算法： 八数码问题 小结
- 问题定义
- 算法流程
- 相关搜索策略
- 单向BFS搜索
- 双向BFS搜索
- 逆向BFS离线打表
- A启发式搜索算法
- 八数码问题变种解法 hdu3567
好久没写博客了，最近开始更一个系列，关于数据结构算法的，希望能形成一个好的体系。 之前写的博文是零碎的知识点小结，只适合自己回顾，不适合他人阅读或者教学，希望这个系列能改善相关的问题，方便他人阅读，分享知识。
问题定义
- 八数码问题： 在3×3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。所谓问题的一个状态就是棋子在棋盘上的一种摆法。棋子移动后，状态就会发生改变。解八数码问题实际上就是找出从初始状态到达目标状态所经过的一系列中间过渡状态。
八数码问题一般使用搜索法来解。搜索法有广度优先搜索法、双向广度优先算法、深度优先搜索法、A*算法等。这里通过用不同方法解八数码问题来比较一下不同搜索法的效果。关于搜索问题，往往重要的是相关的搜索策略的选择。策略选择的好，效率就会有非常大的差异。
oj题目：PKU(1077) HDOJ(1043) ZOJ(1217) 由于测试数据的不同各平台状态不同
- 变种：hdu 3567等
算法流程：
- cantor算法+奇偶性判断（或者逆序对数目判断）是否存在解，若有解，转2； 否则退出
- 根据环境选择搜索策略进行搜索求解，本文以典型的搜索算法： BFS，双向BFS， 离线算法，A*算法为例进行讲解
相关搜索策略
单向BFS搜索
#include8-i];
}
return ret;
}
int BFS(const Node& st,int edval){
memset(vis,false,sizeof(vis));
while(!Q.empty())Q.pop();
pre.clear();
Q.push(st);
vis[st.status]=true;
pre[st.status]=make_pair(-1,-1);
while(!Q.empty()){
Node u=Q.front();
Q.pop();
if(u.status==edval)return u.cnt;
for(int di=0;di<4;di++){
Node v=u;
v.ri=u.ri+dir[di][0];
v.ci=u.ci+dir[di][1];
if(!InMap(v.ri,v.ci))continue;
int upos=3*u.ri+u.ci;
int vpos=3*v.ri+v.ci;
swap(v.s[upos],v.s[vpos]);
v.status=Cantor(v.s);
if(vis[v.status])continue;
vis[v.status]=true;
v.cnt=u.cnt+1;
Q.push(v);
pre[v.status]=make_pair(u.status,di);
if(v.status==edval)return v.cnt;
}
}
return -1;
}
int main(){
#ifdef L_JUDGE
freopen("in.txt","r",stdin);
// freopen("out.txt","w",stdout);
#endif
fac[0]=1;
for(int i=1;i<9;i++)fac[i]=i*fac[i-1];
ed.ri=ed.ci=2;
for(int i=0;i<9;i++){
ed.s[i]=i+1;
}
ed.status=Cantor(ed.s);
while(cin>>in[0]){
for(int i=1;i<9;i++)cin>>in[i];
for(int ri=0;ri<9;ri++){
if('x'==in[ri]){
st.s[ri]=9;
st.ri=ri/3;
st.ci=ri%3;
}
else st.s[ri]=in[ri]-'0';
}
st.status=Cantor(st.s);
st.cnt=0;
int flag=BFS(st,ed.status);
if(-1==flag)puts("unsolvable");
else{
char ans[1000];
char ch[5]="udlr";
int k=ed.status;
ans[flag]=0;
while(k!=st.status){
flag--;
ans[flag]=ch[pre[k].second];
k=pre[k].first;
}
puts(ans);
}
}
#ifdef L_JUDGE
fclose(stdin);
fclose(stdout);
// system("out.txt");
#endif
return 0;
}
双向BFS搜索
#includeswitch(path[i]){
case 0:
putchar('d');
break;
case 1:
putchar('u');
break;
case 2:
putchar('r');
break;
case 3:
putchar('l');
break;
}
}
}
int main(){
#ifdef L_JUDGE
freopen("in.txt","r",stdin);
// freopen("out.txt","w",stdout);
#endif
char ch;
while(cin>>ch){
if(ch=='x'){
s1.eight[0]=9;
s1.space=0;
}else{
s1.eight[0]=ch-'0';
}
for(int i=1;i<9;i++){
cin>>ch;
if(ch=='x'){
s1.eight[i]=9;
s1.space=i;
}else{
s1.eight[i]=ch-'0';
}
}
s1.status=Cantor(s1.eight);
for(int i=0;i<9;i++){
s2.eight[i]=(i+1);
}
s2.space=8;
s2.status=Cantor(s2.eight);
if(!bSolve(s1.eight)){
puts("unsolvable");
}else{
TBFS();
if(found){
if(s1.status!=status)PrintPath1(father1,move1);
if(s2.status!=status)PrintPath2(father2,move2);
putchar('\n');
}else
puts("unsolvable");
}
}
#ifdef L_JUDGE
fclose(stdin);
fclose(stdout);
// system("out.txt");
#endif
return 0;
} 逆向BFS+离线打表
#includeA*启发式搜索算法
#includereturn false;
else if((f==p.f)&&(hreturn false;
return true;
}
};
const int dir[4][2]={-1,0,1,0,0,-1,0,1};
const char d[10]="udlr";
char input[50];
int fac_n[10];
Node st,ed;
bool vis[MAXN];
void Init(){
fac_n[0]=fac_n[1]=1;
for(int i=2;i<9;i++){
fac_n[i]=i*fac_n[i-1];
}
}
int Cantor(int a[]){
int ret=0;
for(int i=0;i<9;i++){
int cnt=0;
for(int j=i+1;j<9;j++){
if(a[i]>a[j])cnt++;
}
ret+=cnt*fac_n[9-i-1];
}
return ret;
}
bool bSolve(const Node &p){
int cnt=0;
for(int i=0;i<9;i++){
for(int j=i+1;j<9;j++){
if(p.s[i]>p.s[j]&&p.s[i]&&p.s[j])cnt++;
}
}
if(cnt&1)return false;
else return true;
}
int Get_H(const Node &p){
int ret=0;
for(int i=0;i<9;i++){
int t=p.s[i]-1;
int ri=t/3;
int ci=t%3;
ret+=abs(ri-i/3)+abs(ci-i%3);
}
return ret;
}
bool InMap(int ri,int ci){
return ri>=0&&ri<3&&ci>=0&&ci<3;
}
priority_queue SQ;
pair<int,int> path[MAXN];
void BFS(const Node &st,const Node &ed){
memset(vis,false,sizeof(vis));
memset(path,-1,sizeof(path));
while(!SQ.empty())SQ.pop();
SQ.push(st);
path[st.status]=make_pair(-1,-1);
vis[st.status]=true;
while(!SQ.empty()){
Node u=SQ.top();
SQ.pop();
if(u.status==ed.status)return ;
for(int di=0;di<4;di++){
Node v=u;
v.ri=u.ri+dir[di][0];
v.ci=u.ci+dir[di][1];
if(!InMap(v.ri,v.ci))continue;
int ti=3*v.ri+v.ci;
swap(v.s[ti],v.s[3*u.ri+u.ci]);
v.status=Cantor(v.s);
if(vis[v.status])continue;
vis[v.status]=true;
v.g=u.g+1;
v.h=Get_H(v);
v.f=v.g+v.h;
SQ.push(v);
path[v.status]=make_pair(u.status,di);
if(v.status==ed.status)return;
}
}
}
void Print(int si,int ed){
if(si==ed)return;
Print(path[si].first,ed);
putchar(d[path[si].second]);
}
int main(){
#ifdef L_JUDGE
freopen("in.txt","r",stdin);
// freopen("out.txt","w",stdout);
#endif
while(cin.getline(input,50,'\n')){
Init();
ed.ri=ed.ci=2;
for(int i=0;i<9;i++){
ed.s[i]=(i+1)%9;
}
ed.status=Cantor(ed.s);
int si=0;
for(int i=0;input[i];i++){
if(input[i]!=' '){
if(input[i]=='x'){
st.s[si]=0;
st.ri=si/3;
st.ci=si%3;
}else{
st.s[si]=input[i]-'0';
}
si++;
}
}
st.status=Cantor(st.s);
st.g=0;
st.h=Get_H(st);
st.f=st.h+st.g;
if(!bSolve(st)){
cout<<"unsolvable"<else{
BFS(st,ed);
int k=ed.status;
Print(ed.status,st.status);
printf("\n");
}
}
#ifdef L_JUDGE
fclose(stdin);
fclose(stdout);
// system("out.txt");
#endif
return 0;
}
八数码问题变种解法 hdu3567
//重新编码初始状态和终点状态
//前期预处理+打表
#include0;
printf("Case %d: %d\n%s\n",ti,anslen,ans);
}
#ifdef L_JUDGE
fclose(stdin);
fclose(stdout);
// system("out.txt");
#endif
return 0;
}