HDU 1254 推箱子 解题报告

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或BFS判断人能否到达箱子的一侧。个人认为在判断人能否到达的时候，用DFS更好一些，因为并不需要求人到箱子的一侧需要的最少步数。

       本题要用两个vis数组。一个vis数组对应箱子的移动，只需在每次执行一次样例前memset即可，因为只要在一次样例中，只要已经有方案到达过某格，之后到达该格的其他方案所需时间必定大于等于第一个方案到达该格的时间；另一个vis数组需要在每次搜索判断人能否到达前，都memset一次，因为数组不大，我当时就直接在子函数里声明了。

        注意人不能出边界，也不能踩在箱子上23333。箱子当然也不能出边界。

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<queue>
#include<stack>
using namespace std;

int t,m,n;
int map[8][8];
int dir[4][2]={0,1,0,-1,-1,0,1,0};
struct Node
{
    int manx,many,thx,thy;
    int num;
};

int visited[8][8][4];

int bfs(struct Node o,int x,int y)
{
    int vis[8][8];
    memset(vis, 0, sizeof(vis));
    
    queue<Node> st;
    st.push(o);
    
    while(!st.empty())
    {
        struct Node no1,no2;
        no1=st.front();
        st.pop();
        
        if(no1.manx==x&&no1.many==y)
        {
            return 1;
        }
        
        
        for(int i=0;i<4;i++)
        {
            no2=no1;
            no2.manx+=dir[i][0];
            no2.many+=dir[i][1];
            if(no2.manx==no2.thx&&no2.many==no2.thy)
                continue;
            if(no2.manx<0||no2.manx>=m||no2.many<0||no2.many>=n)
                continue;
            if(vis[no2.manx][no2.many])
            {
                //printf(" -1");
                continue;
            }
            if(map[no2.manx][no2.many]==1)
                continue;
            
            vis[no2.manx][no2.many]=1;
            st.push(no2);
        }
    }
    
    
    
    return -1;
}

int main()
{
    scanf("%d",&t);
    while(t--)
    {
        int ans=-1;
        scanf("%d%d",&m,&n);
        
        struct Node first;
        queue<Node> q;
        
        
        for(int i=0;i<m;i++)
            for(int j=0;j<n;j++)
            {
                
                scanf("%d",&map[i][j]);
                if(map[i][j]==2)
                {
                    first.thx=i;
                    first.thy=j;
                }else if (map[i][j]==4)
                {
                    first.manx=i;
                    first.many=j;
                }
            }
        
        
        first.num=0;
        memset(visited, 0, sizeof(visited));
        
        q.push(first);
        
        
        while(!q.empty())
        {
            struct Node order,next;
            order=q.front();
            q.pop();
            
            if(map[order.thx][order.thy]==3)
            {
                ans=order.num;
                break;
            }
            for(int i=0;i<4;i++)
            {
                next=order;
                next.manx=next.thx;
                next.many=next.thy;
                next.thx+=dir[i][0];
                next.thy+=dir[i][1];
                if(next.thx<0||next.thx>=m||next.thy<0||next.thy>=n)
                    continue;
                if(visited[next.thx][next.thy][i])
                    continue;
                if(map[next.thx][next.thy]==1)
                    continue;
                int x,y;
                x=next.manx-dir[i][0];
                y=next.many-dir[i][1];
                if(x<0||x>=m||y<0||y>=n)
                    continue;
                
                int b=bfs(order,x,y);
                if(b== -1)
                    continue;
                
                
                visited[next.thx][next.thy][i]=1;
                next.num++;
                q.push(next);
            }
        }
        
        printf("%d\n",ans);
        
    }
    return 0;
}