【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


#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;
}

【后记】

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

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

猜你喜欢

转载自blog.csdn.net/qq_41727666/article/details/83019334