O - 推箱子 HDU - 1254(bfs_box + bfs_man)

O - 推箱子 HDU - 1254

推箱子是一个很经典的游戏.今天我们来玩一个简单版本.在一个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

思路如下

此题⚠️：

• 在人不推箱子的时候，箱子也是障碍物
• 箱子可以重复走某个位置，但是这个 位置 的每个方向只能走一次（因为 在某个位置 某个方向上重复走 是浪费步数的）
• 箱子在某个位置能否被移动，要看 人 能能否从上一次移动之后人所处的位置 —> 移动到 现在箱子后面的位置（这是因为：人只有先到达箱子后面这个位置 才可以去推箱子。）

题解如下

#include
#include
#include
using namespace std;
int m,n;
int map[8][8],mark[8][8][4];	//mark 是用来标记某个位置的某个方向是否被走过。
int mov[4][2] = { {1,0},{0,1},{-1,0},{0,-1} };
int b_x,b_y,m_x,m_y,e_x,e_y;  	//（b_x,b_y）箱子的位置，（m_x,m_y）人的出发位置，（e_x , e_y）终点
int vis[8][8];		//标记人是否到达某个位置了

struct fNode
{
    int x,y;
};
struct Node
{
    int x,y,t;
    fNode last;		//箱子没有被推动之前的位置
}st,ed,s,e;			//st 箱子当前的位置（箱子没有被推动之前的位置），箱子被推动之后将要到达的位置
queue<Node> q,m_q;

bool good_man(int x,int y,int b_x,int b_y)		//检查 “人” 的边界
{	//（b_x , b_y）箱子当前的位置（此时把它看作 “障碍物“）
    if(x >= 0 && y >= 0 && x < m && y < n && (x != b_x || y != b_y) && map[x][y] != 1 && ! vis[x][y])
        return true;
    return false;
}
bool good_box(int x,int y,int i)	//检查“”的边界
{
    if(x >= 0 && y >= 0 && x < m && y < n && map[x][y] != 1 && ! mark[x][y][i])
        return true;
    return false;
}
bool limit(int x,int y)			//边界检查
{
    if(x >= 0 && y >= 0 && x < m && y < n && map[x][y] != 1)
        return true;
    return false;
}

//这bfs_man 是用来判断“人“能否从上次推向之后人的位置（sx,sy）到 当前推箱子需要到达箱子后面的位置（ex,ey）
bool bfs_man(int sx,int sy,int ex,int ey,int b_x,int b_y)
{
    //初始化、赋值、做标记、压队列
    bool flag = 0;
    memset(vis , 0 , sizeof(vis));
    while(! m_q.empty()) m_q.pop();
    s.x = sx;
    s.y = sy;
    vis[s.x][s.y] = 1;
    m_q.push(s);
    while(! m_q.empty())
    {
        s = m_q.front();
        m_q.pop();
        if(s.x == ex && s.y == ey)
        {
            flag = 1;
            break;
        }

        for(int i = 0; i < 4; i ++)
        {
            e.x = s.x + mov[i][0];
            e.y = s.y + mov[i][1];
            if(good_man(e.x , e.y , b_x, b_y))
            {
                vis[e.x][e.y] = 1;
                m_q.push(e);
            }
        }
    }
    return flag;
}

//这个bfs 使用判断 箱子能否从起始位置 走到 终点位置（期间需要 bfs_man 来协助判段，人能否 到达推箱子的指定位置）
bool bfs()
{
    //初始化、赋值、标记、压队列
    bool Flag = 0;
    memset(mark , 0 , sizeof(mark));
    while(! q.empty()) q.pop();
    st.x = b_x;		//箱子当前位置
    st.y = b_y;
    st.last.x = m_x;	//这里假定 上一次 移动之前箱子的位置
    st.last.y = m_y;
    st.t = 0;
    q.push(st);
    while(! q.empty())
    {
        st = q.front();
        q.pop();

        if(st.x == e_x && st.y == e_y)
        {
            Flag = 1;
            printf("%d\n",st.t);
            break;
        }

        for(int i = 0; i < 4; i ++)
        {
        //(ed.x,ed.y) 箱子将要被推倒的位置
        //(st.x,st.y) 箱子将要被推倒的位置
        // 为了能把箱子将（ed.x,ed.y），人需要到达箱子后面的位置要(pos.x,pos.y)
            ed.x = st.x + mov[i][0];	
            ed.y = st.y + mov[i][1];
            ed.t = st.t + 1;
            ed.last.x = st.x;	//上一次箱子的位置
            ed.last.y = st.y;
            fNode pos;
            pos.x = st.x - mov[i][0];
            pos.y = st.y - mov[i][1];
            if(good_box(ed.x , ed.y, i) && limit(pos.x , pos.y) && bfs_man(st.last.x , st.last.y , pos.x , pos.y , st.x , st.y))
            {
                mark[ed.x][ed.y][i] = 1;
                q.push(ed);
            }
        }
    }
    return Flag;
}


int main()
{
 //   freopen("T.txt","r",stdin);
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d %d",&m,&n);
        for(int i = 0; i < m; i ++)
            for(int j = 0; j < n; j ++)
            {
                scanf("%d",&map[i][j]);
                if(map[i][j] == 2)
                    b_x = i , b_y = j;
                else if(map[i][j] == 3)
                    e_x = i , e_y = j;
                else if(map[i][j] == 4)
                    m_x = i , m_y = j;
            }
        if(! bfs())
            cout<<-1<<endl;
    }
    return 0;
}