HDU1254 bfs

推箱子

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 7831    Accepted Submission(s): 2243

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

 

Author

Ignatius.L & weigang Lee

代码：

/*
很明显是bfs，但需要再用一个bfs或dfs判断人能否走到箱子的后面去推他。用一个四维数组记录
人和箱子的位置状态，箱子可以重复经过某一位置但是人和箱子组成的四维的位置只能经过一次，
一定要注意搬运工可以有多个！！！
*/
#include<iostream>
#include<queue>
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
int t,n,m;
int dir[4][2]={1,0,-1,0,0,1,0,-1};
struct Lu
{
    int mp[8][8],sx,sy,ex,ey,cnt;
    bool vis[8][8][8][8];
}L;
struct po
{
    int x,y;
    bool vi[10][10];
};
int dfs(int x1,int y1,int p[8][8])
{
    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++){
            if(p[i][j]==4){    //找搬运工
                int x2=i,y2=j;
                queue<po>q;
                po p1,p2;
                memset(p1.vi,0,sizeof(p1.vi));
                p1.x=x2;p1.y=y2;p1.vi[x2][y2]=1;
                q.push(p1);
                while(!q.empty()){
                    p2=q.front();
                    q.pop();
                    if(p2.x==x1&&p2.y==y1)
                        return 1;
                    for(int i=0;i<4;i++){
                        int x=p2.x+dir[i][0],y=p2.y+dir[i][1];
                        if(x>=0&&x<n&&y>=0&&y<m&&p[x][y]!=1&&p[x][y]!=2&&!p2.vi[x][y]){
                            p1=p2;
                            p1.x=x;p1.y=y;p1.vi[x][y]=1;
                            q.push(p1);
                        }
                    }
                }
            }
        }
    }
    return 0;
}
int bfs()
{
    queue<Lu>q1;
    memset(L.vis,0,sizeof(L.vis));
    q1.push(L);
    Lu L1,L2;
    int cnt=0;
    while(!q1.empty()){
        L1=q1.front();
        q1.pop();
        if(L1.sx==L1.ex&&L1.sy==L1.ey)
            return L1.cnt;
        for(int i=0;i<4;i++){
            int x=L1.sx+dir[i][0],y=L1.sy+dir[i][1];
            if(x>=0&&x<n&&y>=0&&y<m&&L1.mp[x][y]!=1&&L1.mp[x][y]!=3&&dfs(x,y,L1.mp)){
                int a=L1.sx-dir[i][0],b=L1.sy-dir[i][1];
                if(a>=0&&a<n&&b>=0&&b<m&&L1.mp[a][b]!=1&&!L1.vis[a][b][L1.sx][L1.sy]){
                    L2=L1;
                    L2.vis[a][b][L1.sx][L1.sy]=1;
                    L2.sx=a;L2.sy=b;
                    L2.mp[x][y]=0;
                    L2.mp[L1.sx][L1.sy]=4;
                    L2.mp[a][b]=2;
                    L2.cnt=L1.cnt+1;
                    q1.push(L2);
                }
            }
        }
    }
    return -1;
}
int main()
{
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&m);
        memset(L.mp,0,sizeof(L.mp));
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                scanf("%d",&L.mp[i][j]);
                if(L.mp[i][j]==2) {L.sx=i;L.sy=j;}
                if(L.mp[i][j]==3) {L.ex=i;L.ey=j;}
            }
        }
        int ans=bfs();
        cout<<ans<<endl;
    }
    return 0;
}