HDU 1254 推箱子（双重bfs）

最新推荐文章于 2020-03-09 23:45:45 发布

小白菜小青菜

最新推荐文章于 2020-03-09 23:45:45 发布

阅读量317

点赞数

分类专栏： ACM_搜索

本文链接：https://blog.csdn.net/lihao161530340/article/details/78184363

版权

ACM_搜索专栏收录该内容

28 篇文章 0 订阅

订阅专栏

这是一个关于推箱子的经典问题简化版，玩家需将箱子从起始位置推到目标位置。游戏规则包括：搬运工只能推不能拉箱子，且遇到角落和墙壁时箱子会受限制。题目要求计算最少移动格数，若无法达到目标则输出-1。解决方案可能涉及双重 BFS 算法来搜索最短路径。

摘要由CSDN通过智能技术生成

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

推箱子大家都应该玩过，这道题注意一下三点就好。

1.人能走到推箱子的那个位置
2.人不能穿过箱子.
3.箱子可以回到前一状态的位置，但不是同一方向回到的.

#include<algorithm>
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
struct node
{
    int x,y,xx,yy,step;
}as,ass,ad;
int mapp[10][10];
int state[10][10][4];
int dir[4][2]={0,1,0,-1,1,0,-1,0};
int n,m,k,x1,x2,y3,y2;
int st(int b,int c,int sx,int sy,int xxx,int yyy)
{
    int stat[10][10];
    memset(stat,0,sizeof(stat));
    queue<node>aa;
    node ax,ay,axx;
    ay.x=xxx;
    ay.y=yyy;
    aa.push(ay);
    stat[xxx][yyy]=1;
    while(!aa.empty())
    {
        axx=aa.front();
        aa.pop();
        if(axx.x==b&&axx.y==c)
        {
            return 1;
        }
        for(int i=0;i<4;i++)
        {
            ax.x=axx.x+dir[i][0];
            ax.y=axx.y+dir[i][1];
            if(0<=ax.x&&ax.x<n&&0<=ax.y&&ax.y<m&&mapp[ax.x][ax.y]!=1&&stat[ax.x][ax.y]==0)
            {
                if(ax.x==sx&&ax.y==sy)
                {
                    stat[ax.x][ax.y]=1;
                    continue;
                }
                stat[ax.x][ax.y]=1;
                aa.push(ax);
            }
        }
    }
    return 0;
}
void dfs()
{
    queue<node>a;
    ad.x=x1;
    ad.y=y3;
    ad.step=0;
    ad.xx=x2;
    ad.yy=y2;
    a.push(ad);
    while(!a.empty())
    {
        ass=a.front();
        a.pop();
        if(mapp[ass.x][ass.y]==3)
        {
            printf("%d\n",ass.step);
            return ;
        }
        as.xx=ass.x;
        as.yy=ass.y;
        as.step=ass.step+1;
        for(int i=0;i<4;i++)
        {
            as.x=ass.x+dir[i][0];
            as.y=ass.y+dir[i][1];
            if(0<=as.x&&as.x<n&&as.y>=0&&as.y<m&&state[as.x][as.y][i]==0&&mapp[as.x][as.y]!=1)
            {
                int b,c;
                b=ass.x-dir[i][0];
                c=ass.y-dir[i][1];
                if(b>=0&&c>=0&&st(b,c,ass.x,ass.y,ass.xx,ass.yy))
                {
                    state[as.x][as.y][i]=1;
                    a.push(as);
                }
            }
        }
    }
    printf("-1\n");
}
int main()
{
    scanf("%d",&k);
    while(k--)
    {
        scanf("%d%d",&n,&m);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                scanf("%d",&mapp[i][j]);
                if(mapp[i][j]==2)
                    x1=i,y3=j;
                if(mapp[i][j]==4)
                    x2=i,y2=j;
            }
        }
        memset(state,0,sizeof(state));
        dfs();
    }
    return 0;
}