编程笔试——推箱子

头条的笔试题，有一题编程是推箱子问题，之前网易也有类似的题目，思路基本上是一样的。

所谓“推箱子”，就是在一个M*N的地图上，有1个玩家、1个箱子、1个目的地以及若干障碍，其余是空地。玩家可以往上下左右4个方向移动，但是不能移动出地图或者移动到障碍里去。如果往这个方向移动推到了箱子，箱子也会按这个方向移动一格，当然，箱子也不能被推出地图或推到障碍里。当箱子被推到目的地以后，游戏目标就达成了。

题目给出的是游戏开始时的地图布局，要求玩家最少需要移动多少步才能够将游戏目标达成。

输入描述:
每个测试输入包含1个测试用例
第一行输入两个数字M，N表示地图的大小。
接下来有M行，每行包含N个字符表示该行地图。其中空格表示空地、S表示玩家、B表示箱子、E表示目的地、*表示障碍。
每个地图必定包含1个玩家、1个箱子、1个目的地。

输出描述:
输出一个数字表示玩家最少需要移动多少步才能将游戏目标达成。当无论如何达成不了的时候，输出-1。

两个例子：

4 4
....
..BE
....
.S..


6 6
...*..
......
*B**..
..**.*
..S...
.E*...

这题乍看很难，不知道如何下手，但是之前做过，就好说了，基本上就是暴力搜索，算法思想是BFS。
BFS，全称Breadth First Search，是一种广度优先算法。本质上是一种盲目搜索，直到找到结果。一般情况下，从展开节点开始，子节点会被加入一个先进先出的队列，尚未被检验过的邻居节点放在open容器中，而经过检验的则放到closed容器中。

结合代码来一步步分析吧。

首先，我们把输入做出来。

int m,n;
vector<vector<char>> vec;

    cin>>m>>n;
    vec = vector<vector<char>>(m, vector<char>(n));
    int sx, sy, bx, by, ex, ey; //人、箱子、目的地的地址
    //输入地图并保存三个地址
    for(int i = 0; i < m; i++)
        for(int j = 0; j < n; j++)
        {
            char ch;
            cin>>ch;
            vec[i][j] = ch;
            if(ch == 'S')
            {
                sx = i; sy = j;
            }
            if(ch == 'B')
            {
                bx = i; by = j;
            }
            if(ch == 'E')
            {
                ex = i; ey = j;
            }
        }

这里需要注意的是m、n和vec都需要设成全局变量，为了方便我们后面一个判定函数的实现。

然后vec = vector<vector<char>>(m, vector<char>(n));这一句初始化的一定需要，规定了我们二维数组的格式，以便我们后面用下标访问元素。之前这儿没注意，输入一行就崩溃。
另外，也可以用push的方式进行插入，就没有这个问题了。

除了输入地图，我们也需要记录S、B、E这三个点的位置。

当我们开始搜索最短路径时，主要有两个对象需要注意。一个是记录人和箱子状态的四维矩阵status，另一个是保存待遍历状态的队列que。
这里所说的状态就是人和箱子所在位置，分别取他们的横纵坐标构成的，如(sx,sy,bx,by)。
当发生移动后（不管只有人移动，还是人推着箱子移动）处于某一个状态，矩阵status会修改当前状态所对应的值，如初始状态为1。
当形成一个状态时，队列que会将该状态作为某个元素添加进队列，并在之后进行遍历。

    //四维数组记录人和箱子的状态
    int status[10][10][10][10];
    status[sx][sy][bx][by] = 1;
    //队列保存待检测的状态
    queue<vector<int>> que;
    que.push({sx,sy,bx,by});

开始搜索了，从初始状态开始，也即从队列中的第一个元素开始遍历。

//开始遍历队列了
    while(!que.empty())
    {
        //拿到待检测的状态
        vector<int> test = que.front();
        que.pop();
        sx = test[0];
        sy = test[1];
        bx = test[2];
        by = test[3];
        cout<<"("<<sx<<","<<sy<<")("<<bx<<","<<by<<")"<<endl;

        ......
    }

构造一个表示移动方向的数组move。

vector<vector<int>> move = {{1,0},{-1,0},{0,1},{0,-1}};

另外，我们还需要写一个函数，判断当前所在位置是否合法。

//判断该位置是否合法
bool valid(int x, int y)
{
    if(x >= 0 && x < m && y >= 0 && y < n && vec[x][y] != '*')
        return true;
    else
        return false;
}

人开始要推箱子了，遍历上下左右四个方向。

    for(int k = 0; k < 4; k++)
    {
        cout<<k<<":";
        int msx = sx + move[k][0];
        int msy = sy + move[k][1];
        //要么人还没有推到箱子
        if(valid(msx,msy) && (msx != bx || msy != by) && (status[msx][msy][bx][by] == 0))
        {
            cout<<"("<<msx<<","<<msy<<")("<<bx<<","<<by<<")"<<endl;
            status[msx][msy][bx][by] = status[sx][sy][bx][by] + 1;
            que.push({msx,msy,bx,by});
        }
        //要么人推到箱子
        int mbx = bx + move[k][0];
        int mby = by + move[k][1];
        if(valid(mbx,mby) && (msx == bx && msy == by) && (status[msx][msy][mbx][mby] == 0))
        {
            cout<<"("<<msx<<","<<msy<<")("<<mbx<<","<<mby<<")"<<endl;
            if(mbx == ex && mby == ey)
            {
                cout<<status[sx][sy][bx][by];
                return 0;
            }
            status[msx][msy][mbx][mby] = status[sx][sy][bx][by] + 1;
            que.push({msx,msy,mbx,mby});
        }
    }

人开始移动，他的位置会变成:

        int msx = sx + move[k][0];
        int msy = sy + move[k][1];

如果人推到箱子，箱子的位置会变成：

        int mbx = bx + move[k][0];
        int mby = by + move[k][1];

如果人没有推到箱子(msx != bx || msy != by)，且该状态有效，即此时人的位置有效valid(msx,msy)并且该状态不曾存在过(status[msx][msy][bx][by] == 0)，那么直接修改保存状态的矩阵status，并将这个有效状态添加到状态队列que中。
如果人推到了箱子(msx == bx && msy == by)，且该状态有效，即此时箱子的位置有效valid(mbx,mby)并且该状态不曾存在过(status[msx][msy][mbx][mby] == 0)，那么我们首先判断箱子是否到了终点(mbx == ex && mby == ey)，如果到了，则直接输出status[sx][sy][bx][by]就是保存的最短路径，否则按照上面的步骤，修改状态矩阵status并添加有效状态到队列que。

具体实现代码可以见推箱子实例