1326.推箱子

时限：1000ms 内存限制：10000K  总时限：3000ms

描述

绝大多数人都玩过推箱子的游戏，控制一个人将箱子推动到目标位置即获得胜利。现请你编写一个程序，判断将箱子推到目标位置至少需要多少步。

输入

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

输出

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

输入样例

0000000000
0000000300
0100000000
0100000000
0101111100
0000010000
0000010000
0020010040
0000010000
0000010000

 10月27日第二版代码（比较简单）：

#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;    //返回新节点
}

 【10月27日后记】

1.输入一串数字不能用cin啊！！！cin碰到回车之类的才停啊！！！！第一行输入了一串0最后cin只认为是一个0啊！！！！第二行输入了000000030最后cin只认为你输了一个30啊！！！！！

要用cin.get()每次只读一个字符，然后cin.get()-‘0’就是这个字符对应的数字了。要注意把每一行最后的回车丢弃掉。

2.第二次做这道题，累死累活手速全开的写，调试了两遍，二十一分钟AC，还算比较满意。

3.第二版代码和第一版代码，写的时间相差两周半，然而只是在这期间学习了一点小技巧，就让第二版代码比第一版减少了130+行，不得不叹服coding的神奇。生命不息，优化不止。

 10月11日第一版代码（比较繁琐，不建议阅读，仅为记录初学算法时认真码代码的自己）： 

#include <iostream>
#include <queue>

using namespace std;

struct node     //存储状态的节点
{
    int bx,by;  //箱子位置
    int px,py;  //人位置
};

int tx,ty;  //目标位置

int area[10][10];   //地图

queue <node> q1;    //广搜所用队列

int used[10][10][10][10];   //判重数组，用来标记某状态是否出现过

int step[10][10][10][10];   //记录达到某状态所需要的步数

int bfs();  //广搜

bool canmoveto(node n1, int d); //判断出于状态n1的人能否往d方向走

node moveto(node n1, int d);    //获取人走一步的下一个状态，更新used数组和step数组

int main()
{
    node start;
    for(int i=0; i<10; i++) //输入初始状态
    {
        for(int j=0; j<10; j++)
        {
            area[i][j]=cin.get()-'0';   //此处不能用cin啊啊啊啊啊啊啊啊啊！！！

            if(area[i][j]==3)   //目标位置
            {
                tx=i;
                ty=j;
                area[i][j]=0;   //此处需要让它等于0
            }
            else if(area[i][j]==2)  //箱子
            {
                start.bx=i;
                start.by=j;
                area[i][j]=0;
            }
            else if(area[i][j]==4)  //人
            {
                start.px=i;
                start.py=j;
                area[i][j]=0;
            }
        }
        cin.get();      //去除回车符
    }

    used[start.bx][start.by][start.px][start.py]=1; //初始状态标记1，表示出现过

    step[start.bx][start.by][start.px][start.py]=0; //到达初始状态步数为0

    q1.push(start);     //入队

    cout<<bfs()<<endl;

    return 0;
}

int bfs()
{
    node top,next;
    while(!q1.empty())
    {
        top=q1.front();
        q1.pop();

        for(int i=0; i<4; i++)  //令人向4个方向各走一步
        {
            if(canmoveto(top,i))
            {
                next=moveto(top,i); //获得下一个状态节点并更新used数组和step数组

                if(next.bx==tx&&next.by==ty)    //如果箱子位置到达目标地
                {
                    return step[next.bx][next.by][next.px][next.py];    //返回到达目标状态所用步数
                }
                else
                {
                    q1.push(next);
                }
            }
        }
    }
    return -1;  //没搜到返回-1
}

//判断条件：越界、为墙、重复
//还要分两种情况：人要去的那个位置有箱子/无箱子
bool canmoveto(node n1, int d)
{
    switch(d)
    {
        case 0: //人要向左走一步
        {
            if(n1.bx==n1.px&&n1.by+1==n1.py)    //人的左边是箱子
            {
                if(n1.by-1<0)    //越界
                    return false;
                if(area[n1.bx][n1.by-1]==1) //为墙
                    return false;
                if(used[n1.bx][n1.by-1][n1.px][n1.py-1]==1) //重复
                    return false;
                return true;
            }
            else    //人的左边不是箱子
            {
                if(n1.py-1<0)    //越界
                    return false;
                if(area[n1.px][n1.py-1]==1) //为墙
                    return false;
                if(used[n1.bx][n1.by][n1.px][n1.py-1]==1) //重复
                    return false;
                return true;
            }
        }
        case 1: //下
        {
            if(n1.bx-1==n1.px&&n1.by==n1.py)    //人的下边是箱子
            {
                if(n1.bx+1>=10)    //越界
                    return false;
                if(area[n1.bx+1][n1.by]==1) //为墙
                    return false;
                if(used[n1.bx+1][n1.by][n1.px+1][n1.py]==1) //重复
                    return false;
                return true;
            }
            else    //人的下边不是箱子
            {
                if(n1.px+1>=10)    //越界
                    return false;
                if(area[n1.px+1][n1.py]==1) //为墙
                    return false;
                if(used[n1.bx][n1.by][n1.px+1][n1.py]==1) //重复
                    return false;
                return true;
            }
        }
        case 2: //右
        {
            if(n1.bx==n1.px&&n1.by-1==n1.py)    //人的右边是箱子
            {
                if(n1.by+1>=10)    //越界
                    return false;
                if(area[n1.bx][n1.by+1]==1) //为墙
                    return false;
                if(used[n1.bx][n1.by+1][n1.px][n1.py+1]==1) //重复
                    return false;
                return true;
            }
            else    //人的右边不是箱子
            {
                if(n1.py+1>=10)    //越界
                    return false;
                if(area[n1.px][n1.py+1]==1) //为墙
                    return false;
                if(used[n1.bx][n1.by][n1.px][n1.py+1]==1) //重复
                    return false;
                return true;
            }
        }
        case 3: //上
        {
            if(n1.bx+1==n1.px&&n1.by==n1.py)    //人的上边是箱子
            {
                if(n1.bx-1<0)    //越界
                    return false;
                if(area[n1.bx-1][n1.by]==1) //为墙
                    return false;
                if(used[n1.bx-1][n1.by][n1.px-1][n1.py]==1) //重复
                    return false;
                return true;
            }
            else    //人的上边不是箱子
            {
                if(n1.px-1<0)    //越界
                    return false;
                if(area[n1.px-1][n1.py]==1) //为墙
                    return false;
                if(used[n1.bx][n1.by][n1.px-1][n1.py]==1) //重复
                    return false;
                return true;
            }
        }
        default:return false;
    }
}

//获得下一个状态，更新used数组和step数组
node moveto(node n1, int d)
{
    node n2;
    switch(d)
    {
        case 0: //左
        {
            if(n1.bx==n1.px&&n1.by+1==n1.py)    //人的左边是箱子
            {
                n2.bx=n1.bx;
                n2.by=n1.by-1;  //箱子被人推了一格
                n2.px=n1.px;
                n2.py=n1.py-1;
                break;
            }
            else    //人的左边不是箱子
            {
                n2.bx=n1.bx;
                n2.by=n1.by;
                n2.px=n1.px;
                n2.py=n1.py-1;
                break;
            }
        }
        case 1: //下
        {
            if(n1.bx-1==n1.px&&n1.by==n1.py)    //人的下边是箱子
            {
                n2.bx=n1.bx+1;
                n2.by=n1.by;
                n2.px=n1.px+1;
                n2.py=n1.py;
                break;
            }
            else    //人的下边不是箱子
            {
                n2.bx=n1.bx;
                n2.by=n1.by;
                n2.px=n1.px+1;
                n2.py=n1.py;
                break;
            }
        }
        case 2: //右
        {
            if(n1.bx==n1.px&&n1.by-1==n1.py)    //人的右边是箱子
            {
                n2.bx=n1.bx;
                n2.by=n1.by+1;
                n2.px=n1.px;
                n2.py=n1.py+1;
                break;
            }
            else    //人的右边不是箱子
            {
                n2.bx=n1.bx;
                n2.by=n1.by;
                n2.px=n1.px;
                n2.py=n1.py+1;
                break;
            }
        }
        case 3: //上
        {
            if(n1.bx+1==n1.px&&n1.by==n1.py)    //人的上边是箱子
            {
                n2.bx=n1.bx-1;
                n2.by=n1.by;
                n2.px=n1.px-1;
                n2.py=n1.py;
                break;
            }
            else    //人的上边不是箱子
            {
                n2.bx=n1.bx;
                n2.by=n1.by;
                n2.px=n1.px-1;
                n2.py=n1.py;
                break;
            }
        }
    }

    used[n2.bx][n2.by][n2.px][n2.py]=1;

    //到达n2状态的步数，比到达n1状态多了一步
    step[n2.bx][n2.by][n2.px][n2.py]=step[n1.bx][n1.by][n1.px][n1.py]+1;

    return n2;
}