HDU 1254 推箱子 (BFS + DFS)

F - 推箱子
Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d
& %I64u
Submit Status

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

 需要注意的细节问题:
1.对于方向的记录，开个三维数组即可，对于同一个位置不同方向推过来的数据都要记录
2.箱子之所以能够被推动，肯定是人在它的后面，所以在推动箱子时需要判断人从当前位置是否可以到达目的位置，如此这个地方就可以用DFS或者BFS实现(题目数据范围较小，两者看个人爱好选择)
3.如果当前位置有箱子或者墙壁，人是走不去的，换句话说，人没有穿墙术和穿箱术，箱子或者墙壁挡住了去路，也就无法过去了。

BFS中内嵌DFS代码

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <string>
#include <iostream>
#include <queue>
using namespace std;
const int MAXN = 10 + 5;
int O[MAXN][MAXN], N, M;
int dx[] = {1,0,-1,0};
int dy[] = {0,1,0,-1};
int drx[] = {-1,0,1,0};
int dry[] = {0,-1,0,1};
bool vis[MAXN][MAXN][4];
bool rvis[MAXN][MAXN];
bool sc;
int sx, sy, ex, ey, rx, ry;
struct o {
int x, y, rx, ry, b;
o() {}
o(int x, int y, int rx, int ry, int b): x(x), y(y), rx(rx), ry(ry), b(b) {}
};

queue<o> Q;
void DFS(int x, int y,int zx, int zy) {
if(x == zx && y == zy) sc = true;
if(x < 1 || y < 1 || x > N || y > M || rvis[x][y] || O[x][y]) return;
if(sc) return;
rvis[x][y] = true;
for(int i = 0; i < 4; i ++) {
DFS(x + dx[i], y + dy[i], zx, zy);
}
}

int BFS() {
memset(vis, false, sizeof(vis));
while(!Q.empty()) Q.pop();
Q.push(o(sx, sy, rx, ry, 0));
while(!Q.empty()) {
o e = Q.front();
Q.pop();
if(e.x == ex && e.y == ey) {
return e.b;
}
for(int i = 0; i < 4; i ++) {
int nx = e.x + dx[i];
int ny = e.y + dy[i];
int nrx = e.x + drx[i];
int nry = e.y + dry[i];

if(nx < 1 || ny < 1 || nx > N || ny > M || nrx < 1 || nry < 1 || nrx > N || nry > M || vis[nx][ny][i] || O[nx][ny] || O[nrx][nry]) continue;

sc = false;
memset(rvis, false, sizeof(rvis));
O[e.x][e.y] = 1;
DFS(e.rx, e.ry, nrx, nry);
O[e.x][e.y] = 0;
if(!sc) {
continue;
}
vis[nx][ny][i] = true;
Q.push(o(nx, ny, nrx, nry, e.b + 1));
}
}
return -1;
}
int main() {
int T;
scanf("%d", &T);
while(T --) {
scanf("%d%d", &N, &M);
for(int i = 1; i <= N; i ++) {
for(int j = 1; j <= M; j ++) {
scanf("%d", &O[i][j]);
if(O[i][j] == 2) sx = i, sy = j, O[i][j] = 0;
else if(O[i][j] == 3) ex = i, ey = j, O[i][j] = 0;
else if(O[i][j] == 4) rx = i, ry = j, O[i][j] = 0;
}
}
printf("%d\n",BFS());
}
return 0;
}

BFS内嵌BFS

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <string>
#include <iostream>
#include <queue>
using namespace std;
const int MAXN = 10 + 5;
int O[MAXN][MAXN], N, M;
int dx[] = {1,0,-1,0};
int dy[] = {0,1,0,-1};
int drx[] = {-1,0,1,0};
int dry[] = {0,-1,0,1};
bool vis[MAXN][MAXN][4];
bool rvis[MAXN][MAXN];
bool sc;
int sx, sy, ex, ey, rx, ry;
struct o {
int x, y, rx, ry, b;
o() {}
o(int x, int y, int rx, int ry, int b): x(x), y(y), rx(rx), ry(ry), b(b) {}
};
struct u {
int x, y;
u() {}
u(int x, int y):x(x),y(y) {}
};
queue<o> Q;
queue<u> Q2;

bool BFS2(int x, int y, int zx, int zy) {
memset(rvis, false, sizeof(rvis));
while(!Q2.empty()) Q2.pop();//注意清空
Q2.push(u(x, y));
rvis[x][y] = true;
while(!Q2.empty()) {
u e = Q2.front();
Q2.pop();
if(e.x == zx && e.y == zy) return true;
for(int i = 0; i < 4; i ++) {
int nx = e.x + dx[i];
int ny = e.y + dy[i];
if(nx < 1 || ny < 1 || nx > N || ny > M || rvis[nx][ny] || O[nx][ny]) continue;
rvis[nx][ny] = true;
Q2.push(u(nx, ny));
}
}
return false;
}
int BFS() {
memset(vis, false, sizeof(vis));
while(!Q.empty()) Q.pop();//注意清空
Q.push(o(sx, sy, rx, ry, 0));
while(!Q.empty()) {
o e = Q.front();
Q.pop();
if(e.x == ex && e.y == ey) {
return e.b;
}
for(int i = 0; i < 4; i ++) {
int nx = e.x + dx[i];
int ny = e.y + dy[i];
int nrx = e.x + drx[i];
int nry = e.y + dry[i];

if(nx < 1 || ny < 1 || nx > N || ny > M || nrx < 1 || nry < 1 || nrx > N || nry > M || vis[nx][ny][i] || O[nx][ny] || O[nrx][nry]) continue;
O[e.x][e.y] = 1;
sc = BFS2(e.rx, e.ry, nrx, nry);
O[e.x][e.y] = 0;
if(!sc) {
continue;
}
vis[nx][ny][i] = true;
Q.push(o(nx, ny, nrx, nry, e.b + 1));
}
}
return -1;
}
int main() {
int T;
scanf("%d", &T);
while(T --) {
scanf("%d%d", &N, &M);
for(int i = 1; i <= N; i ++) {
for(int j = 1; j <= M; j ++) {
scanf("%d", &O[i][j]);
if(O[i][j] == 2) sx = i, sy = j, O[i][j] = 0;
else if(O[i][j] == 3) ex = i, ey = j, O[i][j] = 0;
else if(O[i][j] == 4) rx = i, ry = j, O[i][j] = 0;
}
}
printf("%d\n",BFS());
}
return 0;
}