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