【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

---

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

#include 
#include 

using namespace std;

int maze[10][10];

struct node
{
    int px,py;  //箱子位置
    int bx,by;  //人位置
    bool useful;    //本节点是否有效
};                  //无效条件：箱子越界、撞墙、节点重复

node start;

int tx,ty;  //目标位置

queue  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<=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 
#include 

using namespace std;

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

int tx,ty;  //目标位置

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

queue  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<=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;
}

---