标签：
题目大意：立体的八数码问题，一次操作是滚动一次方块，问从初始状态到目标状态的最少滚动次数。
题目分析：这道题已知初始状态和目标状态，且又状态数目庞大，适宜用双向BFS。每个小方块有6种状态，整个大方格有9*6^8个状态。每个小方块用一位6进制数表示即可。
注意：状态转移时要谨慎，否则会出现意想不到的错误；
这道题的末状态有256(2^8)个，如果对搜索层数不加限制，即使双向BFS也会TLE的，当限制正向搜索15层逆向搜索15层至正向搜索27层反向搜索3层时都能AC（我下面贴出的程序是这样的），其中正向搜21层，逆向搜9层时在时间上最高效；
对于这道题，开辟一个恰当大小的标记数组也能使时间降低一大截；
代码如下：
# include<iostream>
# include<cstdio>
# include<cmath>
# include<map>
# include<queue>
# include<cstring>
# include<algorithm>
using namespace std;
struct Node
{
int t,n,s;
Node(int _t,int _n,int _s):t(_t),n(_n),s(_s){}
bool operator < (const Node &a) const {
return t>a.t;
}
};
map<char,int>mp;
int ss[8]={1,6,36,216,1296,7776,46656,279936};
int goal[9],path[9],vis[9][1679616],dist[9][1679616];
int d[4][2]={{1,0},{-1,0},{0,-1},{0,1}};
int p[6][4]={
{2,2,5,5},
{4,4,3,3},
{0,0,4,4},
{5,5,1,1},
{1,1,2,2},
{3,3,0,0},
};
priority_queue<Node>q[2];
void dfs(int u,int gp)
{
if(u==9){
int sta=0,cnt=0;
for(int i=0;i<9;++i)
if(path[i]!=-1){
sta=sta+ss[7-cnt]*path[i];
++cnt;
}
dist[gp][sta]=0;
vis[gp][sta]=1;
q[1].push(Node(0,gp,sta));
return ;
}
if(goal[u]==1){
path[u]=0;
dfs(u+1,gp);
path[u]=1;
dfs(u+1,gp);
}else if(goal[u]==2){
path[u]=2;
dfs(u+1,gp);
path[u]=3;
dfs(u+1,gp);
}else if(goal[u]==3){
path[u]=4;
dfs(u+1,gp);
path[u]=5;
dfs(u+1,gp);
}else{
path[u]=-1;
dfs(u+1,gp);
}
}
void init(int x,int y)
{
while(!q[0].empty())
q[0].pop();
while(!q[1].empty())
q[1].pop();
memset(dist,-1,sizeof(dist));
memset(vis,-1,sizeof(vis));
dist[x*3+y][0]=0;
vis[x*3+y][0]=0;
q[0].push(Node(0,x*3+y,0));
for(int i=0;i<9;++i)
if(goal[i]==0){
dfs(0,i);
break;
}
}
int getv(int p,int s)
{
for(int i=1;i<=8-p;++i)
s/=6;
return s%6;
}
int bfs(int id,int step)
{
while(!q[id].empty())
{
Node u=q[id].top();
if(u.t>step)
return -1;
q[id].pop();
if(vis[u.n][u.s]==!id)
return u.t;
int gg[9];
int x=u.n/3,y=u.n%3;
for(int i=0;i<4;++i){
int nx=x+d[i][0],ny=y+d[i][1];
if(nx<0||nx>2||ny<0||ny>2)
continue;
int s=u.s;
for(int j=8;j>=0;--j){
if(j==u.n)
gg[j]=-1;
else{
gg[j]=s%6;
s/=6;
}
}
gg[u.n]=p[gg[nx*3+ny]][i];
gg[nx*3+ny]=-1;
int sta=0,cnt=0;
for(int j=0;j<9;++j)
if(gg[j]!=-1){
sta=sta+ss[7-cnt]*gg[j];
++cnt;
}
if(vis[nx*3+ny][sta]!=id){
if(vis[nx*3+ny][sta]==-1){
vis[nx*3+ny][sta]=id;
dist[nx*3+ny][sta]=u.t+1;
q[id].push(Node(u.t+1,nx*3+ny,sta));
}
else
return u.t+1+dist[nx*3+ny][sta];
}
}
}
return -1;
}
int solve()
{
int step=0;
while(!q[0].empty()||!q[1].empty()){
if(step>30)
return -1;
if(!q[0].empty()&&step<=21){
int k=bfs(0,step);
if(k>30)
return -1;
if(k!=-1)
return k;
}
if(!q[1].empty()&&step<=9){
int k=bfs(1,step);
if(k>30)
return -1;
if(k!=-1)
return k;
}
++step;
}
return -1;
}
int main()
{
//freopen("UVA-1604 Cubic Eight-Puzzle.txt","r",stdin);
mp[‘E‘]=0,mp[‘W‘]=1,mp[‘R‘]=2,mp[‘B‘]=3;
int x,y,gx,gy;
char s[2];
while(scanf("%d%d",&y,&x)&&(x+y))
{
--x,--y;
for(int i=0;i<9;++i){
scanf("%s",s);
goal[i]=mp[s[0]];
}
init(x,y);
printf("%d\n",solve());
}
return 0;
}
UVA-1604 Cubic Eight-Puzzle （双向BFS+状态压缩+限制搜索层数）
标签：
原文地址：http://www.cnblogs.com/20143605--pcx/p/4856199.html
