Hdu 1254 推箱子

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

（搬运工只能推箱子而不能拉箱子，因此如果箱子被推到一个角上(如图)那么箱子就不能再被移动了，如果箱子被推到一面墙上，那么箱子只能沿着墙移动。）

 

思路：很简单的状态搜索题，大概就是对箱子采用BFS的思想，然后判断人是否可以走到箱子的对面（DFS/BFS），由于数据大，可以用四重标记数组来标记（hash[M][M][M][M]）不过有许多细节需要注意。

 

（1）采用DFS/BFS判断人是否可以到达箱子的对面时，要明确人不能穿过箱子，即对箱子标记flag[p.Bx][p.By] = 1;

（2）求箱子的对面求坐标时要保证这个坐标没有超边界。

（3）DFS时不需要回溯。

（4）推箱子时，人的位置不会跟随箱子的移动而移动。

 

CODE：

 

 

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <queue>
using  namespace std;

const  int M =  8;
const  int dx[] = {- 1, 1, 0, 0};
const  int dy[] = { 0, 0,- 1, 1};
int maze[M][M];

int n, m;

int Bx, By, Mx, My;
int Nx, Ny;
int flag[M][M], hash[M][M][M][M];
int Found;

struct node
{
     int Bx, By;
     int Mx, My;
     int step;
};

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

void dfs( int Nx,  int Ny,  int Mx,  int My)
{
     if(Nx == Mx && Ny == My)
    {
        Found =  1;
         return ;
    }
     for( int i =  0; i <  4 && !Found; i++)
    {
         int x = Nx + dx[i];
         int y = Ny + dy[i];
         if(check(x, y) && !flag[x][y])
        {
            flag[x][y] =  1;
            dfs(x, y, Mx, My);
             // flag[x][y] = 0;     只需要知道是否可以到达，而不需要回溯，否则TLE。 
        }
    }
}

void bfs( int Bx,  int By,  int Mx,  int My)
{
    queue<node> Q;
    node p, q;
    p.Bx = Bx, p.By = By, p.Mx = Mx, p.My = My, p.step =  0;
    Q.push(p);
     while(!Q.empty())
    {
        p = Q.front(); Q.pop();
         if(maze[p.Bx][p.By] ==  3)
        {
            printf( " %d\n ", p.step);
             return ;
        }
         for( int i =  0; i <  4; i++)
        {
            q = p;
            q.Bx += dx[i];
            q.By += dy[i];
            Nx = p.Bx-dx[i];
            Ny = p.By-dy[i];    // 箱子对面的坐标
             if(check(q.Bx, q.By)&& check(Nx, Ny) && !hash[q.Bx][q.By][Nx][Ny])   // check(Nx, Ny)
            {
                memset(flag,  0,  sizeof(flag));
                flag[p.Bx][p.By] = flag[Nx][Ny] =  1;    // 标记起点与箱子，确保人不能走过。 
                Found =  0;
                dfs(Nx, Ny, p.Mx, p.My);
                 if(Found)
                {
                    hash[q.Bx][q.By][Nx][Ny] =  1;
                    q.Mx = Nx, q.My = Ny;
                    q.step++;
                    Q.push(q);
                }
            }
        }
    }
    printf( " -1\n ");
     return ;
}

void init()
{
    memset(hash,  0,  sizeof(hash));
    memset(maze,  0,  sizeof(maze));
     for( int i =  0; i < n; i++)
    {
         for( int j =  0; j < m; j++)
        {
            scanf( " %d ", &maze[i][j]);
             if(maze[i][j] ==  2)
            {
                Bx = i;
                By = j;
            }
             if(maze[i][j] ==  4)
            {
                Mx = i;
                My = j;
            }
        }
    }
}

int main()
{
     int T;
    scanf( " %d ", &T);
     while(T--)
    {
        scanf( " %d%d ", &n, &m);
        init();
        bfs(Bx, By, Mx, My);
    }
     return  0;
}