栈和队列应用：迷宫问题

目录

• 迷宫寻路
  • 应用情景
  • 应用解析
• 深度优先
  • 代码实现
  • 运行效果
• 迷宫寻路(广度优先)
  • 应用解析
  • 代码实现
  • 运行效果
• 参考资料

迷宫寻路

应用情景

例如如图所示迷宫，黄色方格代表起点，橙色方格代表终点，绿色方格代表可走路径，蓝色方格代表障碍物。已知这是一个 M × N 大小的迷宫，可以用 0 表示可走路径，1 表示障碍，算法要求实现从迷宫的任意一点出发，试探出一条通向终点的路径。

应用解析

刚看到这个情景，我们是一头雾水的，因此在开始解析之前，我们先把迷宫的构成说明白。如图是一个我已经鸽了很久的 RPG 游戏制作页面，我们发现这个页面和游戏的界面是不一样的，游戏的舞台被一个个方格所切割，制作这类的游戏时，我无论是绘制地图、设置事件还是踩雷遇怪，都是通过对这些方格填充内容实现的，而这些方格在一张确定大小的地图上都是有对应坐标的。

我们是怎么定位可控角色在地图的位置的？其实也是通过这些坐标，确定好角色所在的方格之后就把角色的贴图填充进去。当角色进行移动时，我们先获取这个角色的坐标，确定移动到哪个方格之后，播放设置好的行走图即可实现。不知道爱玩游戏的你是否想过这些问题呢？(笑)

深度优先

现在我们已经把背景说明白了，再来思考一下，我们可以把需求的迷宫描述为一个二维数组，二维数组抽象成几何图形的时候是一个矩阵，因此我们的问题就变成了描述起点到终点坐标的问题了。这个时候我们就要模拟一个玩家，这个玩家要标记他走过的坐标，由于要自动寻路，有东南西北四个维度，因此我们就以这个顺序先作为玩家的寻路顺序。当玩家遇到死路时，就要退回之前走过的路，因此我们就发现了栈结构“后进先出”的特性很适合用于描述走回头路的过程。

代码实现

#include<iostream>
#include<stack>
using namespace std;
#define M 8
#define N 8
typedef struct
{
    int x;    //路径的 x 坐标
    int y;    //路径的 y 坐标
    int next_direction = 1;    //表示方位，由 1 到 4 分别表示东南西北
} unit;
void Labyrinth(int xi, int yi, int xe, int ye);    //走迷宫函数
void exploreWay(int x, int y, stack<unit>& path, unit& a_unit);    //探路函数

int a_maze[M + 2][N + 2] =
{
    {1,1,1,1,1,1,1,1,1,1},
    {1,0,0,1,0,0,0,1,0,1},
    {1,0,0,1,0,0,0,1,0,1},
    {1,0,0,0,0,1,1,0,0,1},
    {1,0,1,1,1,0,0,0,0,1},
    {1,0,0,0,1,0,0,0,0,1},
    {1,0,1,0,0,0,1,0,0,1},
    {1,0,1,1,1,0,1,1,0,1},
    {1,1,0,0,0,0,0,0,0,1},
    {1,1,1,1,1,1,1,1,1,1}
};

int main() 
{
    Labyrinth(1, 1, M, N);
    for (int i = 0; i < M + 2; i++)    //打印迷宫路径
    {
        for (int j = 0; j < N + 2; j++)
        {
            if (a_maze[i][j] == 4)
                cout <<  "  ";
            else
                cout << a_maze[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

void exploreWay(int x, int y, stack<unit>& path, unit& a_unit)
{
    if (a_maze[x][y] == 0)    //该方向路可以走
    {
        a_unit.x = x;
        a_unit.y = y;
        a_maze[x][y] = 2;
        path.push(a_unit);    //新路径入栈
    }
    else    //改变方向，准备下一次探路
        path.top().next_direction++;
}

void Labyrinth(int xi, int yi, int xe, int ye)    //探查下一个可走的路径
{
    stack<unit> path;
    unit a_unit;

    exploreWay(xi, yi, path, a_unit);
    while (!path.empty())
    {
        if (path.top().x == xe && path.top().y == ye)
            break;
        switch (path.top().next_direction)
        {
        case 1:    //向东探路
            exploreWay(path.top().x + 1, path.top().y, path, a_unit);
            break;
        case 2:    //向南探路
            exploreWay(path.top().x, path.top().y + 1, path, a_unit);
            break;
        case 3:    //向西探路
            exploreWay(path.top().x - 1, path.top().y, path, a_unit);
            break;
        case 4:    //向北探路
            exploreWay(path.top().x, path.top().y - 1, path, a_unit);
            break;
        default:    //走到死路
            a_maze[path.top().x][path.top().y] = 9;    //标记为死路
            path.pop();    //栈顶退栈
        }
    }
    while (!path.empty())    //为了打印路径，给迷宫挖空
    {
        a_maze[path.top().x][path.top().y] = 4;
        path.pop();
    }
}

运行效果

• 虽然这段代码是以深度优先搜索为基础写出来的，但是这并不完整，因为理论上深度优先搜索是可以找到所有路径的。解决方案是找到终点之后仍然走回头路，在有岔路的地方再次进行试探，直到没有岔路可走为止。此处只是为了展示栈结构的应用，深度优先搜索并不是我们当前要谈的问题，因此我简化的操作，并且将路径挖空，帮助我们更好地理解。

迷宫寻路(广度优先)

应用解析

在这里我们想利用广度优先的思想来实现，本算法的思想是从 (xi，yi) 开始，利用队列的特点，一层一层扩大搜索的直径，把可走的点都导入到队列中，直到搜索到终点。

不过我这里主要是为了展示队列的应用，因此对于广度优先我在这里不过多阐述，可以自行查阅相关资料理解。这里需要强调的是，由于我们需要得到完整的路径，也就是说搜索过的路径不能够真出队列，以便于我们得到答案，因此就不能使用 STL 库的 queue 容器来实现，自建队列的话就要使用顺序队列来描述。不过我认为此处最适合的是 STL 库的 vector 容器，我们只需要定义两个游标来描述 vector 对象的队列头和尾的位置，就可以使用 vector 的方法来实现插入等操作，我们在解决银行排队问题的时候也是这么做的。

代码实现

#include<iostream>
#include<vector>
using namespace std;
#define M 8
#define N 8
typedef struct
{
    int x;
    int y;    //路径的坐标
    int pre;    //表示该路径前驱的游标
} unit;
int exploreWay(int x, int y, vector<unit>& path, unit& a_unit, int front, int& rear);    //添加单个路径
void Labyrinth(int xi, int yi, int xe, int ye, vector<unit>& min_path);    //路径搜索函数
int a_maze[M + 2][N + 2] =
{
    {1,1,1,1,1,1,1,1,1,1},
    {1,0,0,1,0,0,0,1,0,1},
    {1,0,0,1,0,0,0,1,0,1},
    {1,0,0,0,0,1,1,0,0,1},
    {1,0,1,1,1,0,0,0,0,1},
    {1,0,0,0,1,0,0,0,0,1},
    {1,0,1,0,0,0,1,0,0,1},
    {1,0,1,1,1,0,1,1,0,1},
    {1,1,0,0,0,0,0,0,0,1},
    {1,1,1,1,1,1,1,1,1,1}
};

int main()
{
    vector<unit> min_path;    //存储最短路径
    Labyrinth(1,1, M, N,min_path);
    cout << "最短路径为：" << endl;
    for (int i = min_path.size() - 1; i >= 0; i--)
    {
        cout << "(" << min_path[i].x << " , " << min_path[i].y << ")   ";
        if ((min_path.size() - i) % 5 == 0)
            cout << endl;
    }
	return 0;
}

int exploreWay(int x, int y, vector<unit>& path, unit& a_unit, int front, int& rear)
{
    if (a_maze[x][y] == 0)    //若路径可走
    {
        a_unit.x = x;
        a_unit.y = y;
        a_unit.pre = front;
        path.push_back(a_unit);    //添加路径
        rear++;    //移动尾指针
        a_maze[x][y] = 2;
        return 1;
    }
    return 0;
}

void Labyrinth(int xi, int yi, int xe, int ye, vector<unit>& min_path)    //搜索路径为:(xi,yi)->(xe,ye)
{
    vector<unit> path;    //存储所有可走路径
    unit a_unit;
    int front, rear = -1;

    front = rear;
    exploreWay(xi, yi, path, a_unit, front, rear);    //添加起点路径，同时初始化头尾指针
    while (rear != front)
    {
        front++;                                                 //判断路径东侧结点是否添加
        if (exploreWay(path[front].x + 1, path[front].y, path, a_unit, front, rear) == 1 
                                                                && a_unit.x == xe && a_unit.y == ye)
            break;                                               //判断路径南侧结点是否添加
        if (exploreWay(path[front].x, path[front].y + 1, path, a_unit, front, rear) == 1
                                                                && a_unit.x == xe && a_unit.y == ye)
            break;                                               //判断路径西侧结点是否添加
        if (exploreWay(path[front].x - 1, path[front].y, path, a_unit, front, rear) == 1
                                                                 && a_unit.x == xe && a_unit.y == ye)
            break;                                               //判断路径北侧结点是否添加
        if (exploreWay(path[front].x, path[front].y - 1, path, a_unit, front, rear) == 1
                                                                 && a_unit.x == xe && a_unit.y == ye)
            break;
    }
    while (rear != -1)    //将搜索到的最短路径移动到 min_path
    {
        min_path.push_back(path[rear]);
        rear = path[rear].pre;
    }
}

运行效果

参考资料

《大话数据结构》—— 程杰 著，清华大学出版社
《数据结构教程》—— 李春葆 主编，清华大学出版社
《数据结构(C语言版|第二版)》—— 严蔚敏 李冬梅 吴伟民 编著，人民邮电出版社