LevOJ P1793 求解迷宫问题

问题描述

有一 8×8 的迷宫图，其中 O 表示通路方块，X 表示障碍方块。假设入口位置为 (0,0)，出口为右下角方块位置 (7,7)。设计一个程序求指定入口到出口的一条迷宫路径。

输入描述

8 行，每行 8 个字符表示迷宫。

输入保证至少存在一条合法路径。

输出描述

8 行，每行 8 个字符，空格表示所选路径。

样例输入

OXXXXXXX
OOOOOXXX
XOXXOOOX
XOXXOXXO
XOXXXXXX
XOXXOOOX
XOOOOXOO
XXXXXXXO

样例输出

 XXXXXXX
  OOOXXX
X XXOOOX
X XXOXXO
X XXXXXX
X XX   X
X    X  
XXXXXXX 

思路
首先这题的第一想法是DFS 即深度优先搜索，从(0,0)出发，每次探索4个方向，下右上左，递归调用dfs
注意:当走不通时，要将原来的方块还原为O

#include <iostream>
using namespace std;
char maze[8][8];
void dfs(int x, int y);
void print()
{
    for (int i = 0; i < 8; i++)
    {
        for (int j = 0; j < 8; j++)
            cout << maze[i][j];
        cout << endl;
    }
}
int main()
{
    for (int i = 0; i < 8; i++)
        for (int j = 0; j < 8; j++)
            cin >> maze[i][j];
    dfs(0, 0);
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, -1, 0, 1};
void dfs(int x, int y)
{
    if (x == 7 && y == 7)
    {
        maze[7][7] = ' ';
        print();
        return ;
    }
    else
    {
        if (maze[x][y] == 'O' && x >= 0 && x <= 7 && y >= 0 && y <= 7)
        {
            // 如果x y能走 则置空
            maze[x][y] = ' ';
            for (int i = 0; i < 4; i++)
            {
                maze[x][y] = ' ';
                int newx = x + dx[i];
                int newy = y + dy[i];
                dfs(newx, newy);
                // 若该方向不能走 则将上一个位置复原
                maze[x][y] = 'O';
            }
        }
    }
}

提交后，发现有个样例超时。（该样例设计的太好了。。）估计正好全部走一遍才走通。

 

 

 网上找了很久，也没能找到能优化的地方。 所以改变算法，改用广度优先搜索BFS。

BFS搜索出的路径一定是最小路径（一开始死活想不通为什么，后面突然想通了）

BFS扫描的话，相当于一层一层展开。当达到终点时，结束扫描。相当于把每条路径摆在一起，从头开始比对，那必定是最短的那条路径先结束。

那么怎么实现呢？

由于在STL中queue不能顺序遍历，这里用一个数组作为非循环队列，front和rear分别为队头和队尾，初始时设置为-1，每个进队元素有唯一的下标。

#include <iostream>
using namespace std;
#define MAX 100
int n = 8, H[4] = {0, 1, 0, -1}, V[4] = {-1, 0, 1, 0};
char Maze[8][8];
struct Position
{
    int x, y; //当前方块位置
    int pre;
};
Position qu[MAX];
int front = -1, rear = -1;
void print(int front)
{
    int i, j;
    for (i = 0; i < n; i++)
        for (j = 0; j < n; j++)
            if (Maze[i][j] == '*')
                Maze[i][j] = 'O';
    int k = front;
    while (k != -1)
    {
        Maze[qu[k].x][qu[k].y] = ' ';
        k = qu[k].pre; //向前找
    }
    for (i = 0; i < n; i++)
    {
        for (j = 0; j < n; j++)
            cout << Maze[i][j];
        cout << endl;
    }
}
void BFS(int x, int y)
{
    Position p, p1, p2;
    p.x = x;
    p.y = y;
    p.pre = -1;
    Maze[p.x][p.y] = '*'; //改为*避免重复查找
    rear++;
    qu[rear] = p;
    while (front != rear) //队不空时循环
    {
        front++;
        p1 = qu[front]; //出队p1
        if (p1.x == n - 1 && p1.y == n - 1)
        {
            print(front);
            return;
        }
        for (int k = 0; k < 4; k++)
        {
            p2.x = p1.x + V[k];
            p2.y = p1.y + H[k];
            if (p2.x >= 0 && p2.y >= 0 && p2.x < n && p2.y < n && Maze[p2.x][p2.y] == 'O')
            {
                Maze[p2.x][p2.y] = '*';
                p2.pre = front;
                rear++;
                qu[rear] = p2; //方块p2入队
            }
        }
    }
}
int main()
{
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            cin >> Maze[i][j];
    BFS(0, 0);
}