hdu 1254 推箱子 (bfs+dfs+预处理)

**推箱子**

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 8533 Accepted Submission(s): 2482

Problem Description

推箱子是一个很经典的游戏.今天我们来玩一个简单版本.在一个M*N的房间里有一个箱子和一个搬运工,搬运工的工作就是把箱子推到指定的位置,注意,搬运工只能推箱子而不能拉箱子,因此如果箱子被推到一个角上(如图2)那么箱子就不能再被移动了,如果箱子被推到一面墙上,那么箱子只能沿着墙移动.

现在给定房间的结构,箱子的位置,搬运工的位置和箱子要被推去的位置,请你计算出搬运工至少要推动箱子多少格.

Input

输入数据的第一行是一个整数T(1<=T<=20),代表测试数据的数量.然后是T组测试数据,每组测试数据的第一行是两个正整数M,N(2<=M,N<=7),代表房间的大小,然后是一个M行N列的矩阵,代表房间的布局,其中0代表空的地板,1代表墙,2代表箱子的起始位置,3代表箱子要被推去的位置,4代表搬运工的起始位置.

Output

对于每组测试数据,输出搬运工最少需要推动箱子多少格才能帮箱子推到指定位置,如果不能推到指定位置则输出-1.

Sample Input

1

5 5

0 3 0 0 0

1 0 1 4 0

0 0 1 0 0

1 0 2 0 0

0 0 0 0 0

Sample Output

4

解析:

本题的思路就是边BFS边DFS。箱子每次走的路要判断人能不能走到推这个箱子的位置(DFS)。并且这题要注意的事情有3点：

1.在DFS时箱子此时的位置也要看成障碍物，因为人不能穿箱子。箱子可能嵌在墙中，里面有空位，但人走不进去，唯一的路被箱子堵着

2.箱子可以走回头路，这次回头路的状态是方向。每一个格子只能从4个方向各走一次。所以用visit[x][y][i]来标记[x][y]位置从[i]方向来的状态。

3.在这些考虑了之后你可能会时间超限(可能！反正我是TLE了)，这个时候你可能要进行预处理了。将图预处理一遍，将某些格子某些方向(箱子在这个格子内在这个方向上不能再推了)(例如1240，这时2这个的左右方向就是死方向就只能上下推了，所以要把这个两方向剪去)

#include<cstdio>
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
#define MAXN 10
#define inf 999999999
typedef struct local
{
int x,y;
int px,py;
int time;
}loca;
int direction[4][3]={{1,0},{0,1},{-1,0},{0,-1}};

int map[MAXN][MAXN];
int path[MAXN][MAXN][4];  //用于预处理路径，删去那些左右(或上下)只有一个或没有空位(0)的点，把他们标为1
int visit[MAXN][MAXN][4];
int visit2[MAXN][MAXN];
int n,m,s,ans,boxx,boxy,peox,peoy,d1,d2;

int check(int x,int y)
{
if(x>=1&&x<=n&&y>=1&&y<=m&&map[x][y]!=1)
{
return 1;
}
return 0;
}

int dfs(int x,int y,int px,int py,int bx,int by)
{
int i;
if(px==x&&py==y)
{
return 1;
}
int xx,yy;
for(i=0;i<4;i++)
{
xx=px+direction[i][0];
yy=py+direction[i][1];
if(check(xx,yy)&&(xx!=bx||yy!=by)&&visit2[xx][yy]==0)   //bx,by表示箱子
{
visit2[xx][yy]=1;
if(dfs(x,y,xx,yy,bx,by))
return 1;
visit2[xx][yy]=0;
}

}
return 0;
}

void BFS(loca start)
{
queue<loca>step;
int i;
loca tmp;
step.push(start);
//visit[start.x][start.y]=0;
while(step.size())
{
tmp=step.front();
if(map[tmp.x][tmp.y]==3)
{
ans=tmp.time;
break;
}
step.pop();
loca oth;
int x,y,xx,yy;
for(i=0;i<4;i++)
{
x=tmp.x+direction[i][0];
y=tmp.y+direction[i][1];
xx=tmp.x-direction[i][0];  //人要到达的位置，人不能通过箱子
yy=tmp.y-direction[i][1];
if(path[tmp.x][tmp.y][i]==0)continue; //若之前那格的在这个方向是不可实现的continue
if(check(x,y)&&visit[x][y][i]==0)//进入这个格子的i方向是否已经走过
{
memset(visit2,0,sizeof(visit2));
if(dfs(xx,yy,tmp.px,tmp.py,tmp.x,tmp.y)&&check(xx,yy))//人能否到达推箱子的位置
{
oth.time=tmp.time+1;
oth.x=x;
oth.y=y;
oth.px=xx;
oth.py=yy;
step.push(oth);
visit[x][y][i]=1;
}
}
}
}
}

int main()
{
int i,j,s1,s2,t,k;
loca start;
scanf("%d",&t);
while(t--)
{
scanf("%d%d",&n,&m);
memset(visit,0,sizeof(visit));
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
scanf("%d",&map[i][j]);
if(map[i][j]==2)
{
boxx=i;
boxy=j;
}
if(map[i][j]==4)
{
peox=i;
peoy=j;
}
if(map[i][j]==3)
{
d1=i;
d2=j;
}

}
}
if((boxx==1&&boxy==1)||(boxx==1&&boxy==m)||(boxx==n&&boxy==1)||(boxx==n&&boxy==m))
{
printf("-1\n");
continue;
}
if((boxx==1&&d1!=1)||(boxx==n&&d1!=n)||(boxy==1&&d2!=1)||(boxy==m&&d2!=m))
{
printf("-1\n");
continue;
}
for(i=1;i<=n;i++)            //预处理相当于剪枝
{
for(j=1;j<=m;j++)
{
if(map[i][j]==1)   //若该格子本身不可走，标记为0
{
memset(path[i][j],0,sizeof(path[i][j]));
continue;
}
for(k=0;k<2;k++)
{
int x1,x2,y1,y2;
x1=i+direction[k][0];
y1=j+direction[k][1];
x2=i+direction[k+2][0];
y2=j+direction[k+2][1];
if(check(x1,y1)&&check(x2,y2))//若该格子在一个方向上两边都可以走，标记为1
{
path[i][j][k]=path[i][j][k+2]=1;
}
else
{
path[i][j][k]=path[i][j][k+2]=0;
}
}

}
}
ans=inf;
start.x=boxx;
start.y=boxy;
start.px=peox;
start.py=peoy;
start.time=0;
BFS(start);
if(ans==inf) printf("-1\n");
else printf("%d\n",ans);
}
return 0;
}

附上几组测试数据

3

5 8

1 0 3 0 0 0 0 1

1 0 1 1 1 0 0 0

1 0 1 1 1 0 0 1

4 2 0 0 0 0 0 1

1 1 1 1 0 0 1 1

1

5 5

0 3 0 0 0

1 0 1 4 0

1 0 1 0 0

1 2 1 0 0

1 0 1 0 0

1

5 5

0 4 0 3 1

1 0 0 0 1

0 0 0 0 1

1 0 2 0 1

0 0 0 0 1

4 3

3 0 0

1 0 0

0 0 1

0 2 4

1

5 5

0 3 0 0 0

1 0 1 4 0

0 0 0 1 1

1 0 0 0 1

0 0 2 1 1

1

3 5

1 1 1 1 1

0 0 2 4 3

0 0 0 1 1

1

5 5

0 4 0 0 0

1 2 1 0 0

3 0 0 1 0

1 0 0 1 0

1 0 0 1 0