【NOJ1326】【算法实验三】推箱子

1326.推箱子

时限：1000ms 内存限制：10000K 总时限：3000ms
描述
绝大多数人都玩过推箱子的游戏，控制一个人将箱子推动到目标位置即获得胜利。现请你编写一个程序，判断将箱子推到目标位置至少需要多少步。

输入
推箱子的平面区域为固定大小（10*10），使用10行10列输入推箱子的初始局面。其中，0代表空格，1代表墙，2代表箱子，3代表目标位置，4代表人。
注：游戏中只有一个箱子，一个目标位置，一个人。

输出
输出将箱子推到目标位置的最小步数；若箱子不可能被推到目标位置，输出-1。

输入样例
0000000000
0000000300
0100000000
0100000000
0101111100
0000010000
0000010000
0020010040
0000010000
0000010000

输出样例
34

#include <iostream>
#include <queue>
 
using namespace std;
 
int maze[10][10];
 
struct node
{
    int px,py;  //箱子位置
    int bx,by;  //人位置
    bool useful;    //本节点是否有效
};                  //无效条件：箱子越界、撞墙、节点重复
 
node start;
 
int tx,ty;  //目标位置
 
queue <node> q1;
 
int used[10][10][10][10];   //判重数组
 
int step[10][10][10][10];   //步数数组
 
int walk[4][2]= //走一步后的新坐标变化
{
    0, -1,  //左
    +1, 0,  //下
    0, +1,  //右
    -1, 0   //上
};
 
void input();
 
int bfs();
 
node moveto(node cur, int i);   //返回人向i方向走一格的新节点
 
int main()
{
    input();
 
    cout<<bfs()<<endl;
 
    return 0;
}
 
void input()
{
    for(int i=0; i<10; i++)
    {
        for(int j=0; j<10; j++)
        {
            maze[i][j]=cin.get()-'0';   //将数字按字符读入，再转换成数字
            switch(maze[i][j])
            {
                case 2: //箱子
                {
                    start.bx=i;
                    start.by=j;
                    maze[i][j]=0;   //将此处标记为0，意为“可以走”
                    break;
                }
                case 3: //目标位置
                {
                    tx=i;
                    ty=j;
                    maze[i][j]=0;   //同上
                    break;
                }
                case 4: //人
                {
                    start.px=i;
                    start.py=j;
                    maze[i][j]=0;   //同上
                    break;
                }
                default:break;
            }
        }
        cin.get();  //此处！吃掉回车
    }
 
    //标记初始节点并入队
    used[start.bx][start.by][start.px][start.py]=1;
    step[start.bx][start.by][start.px][start.py]=0;
    q1.push(start);
}
 
int bfs()
{
    node cur,next;
    while(!q1.empty())
    {
        cur=q1.front();
        q1.pop();
 
        for(int i=0; i<4; i++)  //人向4个方向试探
        {
            next=moveto(cur, i);    //返回扩展所得的新节点
 
            if(next.useful)     //若该节点有效
            {
                if(next.bx==tx&&next.by==ty)    //判断箱子是否到达目标位置
                {
                    return step[next.bx][next.by][next.px][next.py];
                }
                else    //还未到达，新节点入队
                {
                    q1.push(next);
                }
            }
        }
    }
    return -1;  //无法到达，返回-1
}
 
//节点无效条件：箱子或人越界、箱子或人撞墙、节点重复
node moveto(node cur, int i)
{
    node next;
 
    next.bx=cur.bx;     //箱子位置暂时不动
    next.by=cur.by;
 
    next.px=cur.px+walk[i][0];  //人向i方向移动一格
    next.py=cur.py+walk[i][1];
 
    if(next.px==next.bx&&next.py==next.by)  //若此时人与箱子位置重叠
    {
        next.bx+=walk[i][0];        //那么箱子也要向i方向移动一格
        next.by+=walk[i][1];
    }
 
    //判断新节点next是否有效
 
    next.useful=false;  //初始为无效
 
    if(next.bx>=0&&next.bx<10&&next.by>=0&&next.by<10       //箱子不越界
       &&next.px>=0&&next.px<10&&next.py>=0&&next.py<10)    //&&人不越界
        {
            if(maze[next.bx][next.by]==0        //箱子所在位置不是墙
               &&maze[next.px][next.py]==0)     //&&人所在位置不是墙
                {
                    if(used[next.bx][next.by][next.px][next.py]==0) //节点不重复
                    {
                        next.useful=true;   //同时满足上述条件，该节点才有效
 
                        //标记“到达过”和“到达步数”
                        used[next.bx][next.by][next.px][next.py]=1;
                        step[next.bx][next.by][next.px][next.py]=
                            1+step[cur.bx][cur.by][cur.px][cur.py];
                    }
                }
        }
 
    return next;    //返回新节点
}