信息学奥赛一本通 1252：走迷宫 | OpenJudge NOI 2.5 2753:走迷宫

【题目链接】

ybt 1252：走迷宫
OpenJudge NOI 2.5 2753:走迷宫

【题目考点】

1. 广搜 迷宫问题

2. 双向广搜

3. 迭代加深搜索

【解题思路】

1. 广搜

设结构体类型的结点保存位置以及步数，队列中保存的是该结构体类型的变量。设vis数组记录一个位置是否已经访问过。
广搜借助队列，首先起点位置入队，而后每次出队一个位置，将该位置可以到达的所有与之相邻的位置入队，同时记录行走步数。如果到达终点位置，输出到达终点时的步数即为从起点到终点的最短距离。
做广搜时一定要坚持：先访问再入队，出队时判断解。
访问一个位置，指该位置在vis数组中设为true。如果出队时再访问，可能会出现重复访问的情况。判断解指判断该位置是否为终点。

2. 双向广搜

初始时同时将起点和终点入队，vis数组记录该位置是从起点出发到达的，还是从终点出发到达的。如果一个位置的周围的位置已访问过，且是从另一个出发点到达的，那么从两个出发点出发形成的路径完成拼接，输出总路径长度。

3. 迭代加深搜索

从起点出发进行限制深度的深搜，限制深度逐次增加，直到找到目标位置。

【题解代码】

解法1：广搜

#include <bits/stdc++.h>
using namespace std;
#define N 45
struct Node//设置结点
{
    int x, y, s;//到(x,y)位置是步数为s 
};
int r, c;//行、列
char mp[N][N];//地图
bool vis[N][N];//vis[i][j]表示第i，j位置是否已访问过
int dir[4][2] = {{-1,0},{1,0},{0,1},{0,-1}}; //方向数组
int bfs()//广搜，返回从左上角走到右下角的最少步数
{
    queue<Node> que;
	vis[1][1] = true;//访问初始位置
	que.push(Node{1, 1, 1});
    while(!que.empty())//如果队列不空
    {
        Node u = que.front();
        que.pop();//出队一个结点
        if(u.x== r && u.y == c)//如果到终点
            return u.s;//返回终点结点上的步数
        for(int i = 0; i < 4; ++i)//遍历四个方向上的位置
        {
            int x = u.x + dir[i][0], y = u.y + dir[i][1], s = u.s + 1;//新的位置，以及步数
            if(x >= 1 && x <= r && y >= 1 && y <= c && vis[x][y] == false && mp[x][y] == '.')
            {//如果在范围内 且 没访问过 且 这个位置是空地
                vis[x][y] = true;//访问x，y位置
                que.push(Node{x, y, s});//该位置及步数构成结点，入队
            }
        }
    }
    return -1;//保持函数每条运行路径都有返回值 
}
int main()
{
    cin >> r >> c;
    for(int i = 1; i <= r; ++i)
        for(int j = 1; j <= c; ++j)
            cin >> mp[i][j];
    cout << bfs();
    return 0;
}

解法2：双向广搜

#include<bits/stdc++.h>
using namespace std;
#define N 45
struct Pair
{
    int x, y;
};
int r, c;
char a[N][N];
int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int vis[N][N];//vis[i][j]：从哪里出发到达(i,j) 1：从起点出发 2：从终点出发 0：未访问 
int dis[N][N];//dis[i][j]：从vis[i][j]出发到达(i,j)的最少步数 
int bfs()
{
    queue<Pair> que;
    vis[1][1] = 1, vis[r][c] = 2;
    que.push(Pair{1, 1});
    que.push(Pair{r, c});
    while(!que.empty())
    {
        int sx = que.front().x, sy = que.front().y;
        que.pop();
        for(int i = 0; i < 4; ++i)
        {
            int x = sx+dir[i][0], y = sy+dir[i][1];
            if(x >= 1 && x <= r && y >= 1 && y <= c && a[x][y] == '.')
            {
                if(vis[x][y] == 0)
                {
                    vis[x][y] = vis[sx][sy];
                    dis[x][y] = dis[sx][sy]+1;
                    que.push(Pair{x, y});
                }
                else if(vis[x][y] != vis[sx][sy])
                    return dis[x][y]+dis[sx][sy]+1;
            }
        }
    }
    return -1; 
}
int main()
{
    cin >> r >> c;
    if(r == 1 && c == 1)
    {
        cout << 1;
        return 0;
    }
    for(int i = 1; i <= r; ++i)
        for(int j = 1; j <= c; ++j)
            cin >> a[i][j];
    cout << bfs()+1 << endl;
    return 0;
}

解法3：迭代加深搜索

注：该解法提交【ybt 1252：走迷宫】会有一个点超时，提交【OpenJudge NOI 2.5 2753:走迷宫】可以通过。

#include<bits/stdc++.h>
using namespace std;
#define N 45
int r, c, dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}}, ans; 
char a[N][N];
bool vis[N][N];//vis[i][j]：(i,j)是否已走过 
//(sx, sy)：当前所在位置 dep：当前经过的格子数 maxDep：最大经过的格子数 
void dfs(int sx, int sy, int dep, int maxDep)
{
    if(ans > 0)
        return;
    if(dep == maxDep)
    {
        if(sx == r && sy == c)
     		ans = maxDep;
        return;
    }
    if(dep+r-sx+c-sy > maxDep)//启发式剪枝 在到(sx,sy)前走了dep步，接下来最少走从(sx,sy)到(r,c)的曼哈顿距离(r-sx+c-sy)，如果走最短，还比最优解maxDep大，实际只会比maxDep更大，应该剪枝。 
    	return;
    for(int i = 0; i < 4; ++i)
    {
        int x = sx+dir[i][0], y = sy+dir[i][1];
        if(x >= 1 && x <= r && y >= 1 && y <= c && !vis[x][y] && a[x][y] == '.')
        {
            vis[x][y] = true;
            dfs(x, y, dep+1, maxDep);
            vis[x][y] = false;  
        }
    }
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
    cin >> r >> c;
    for(int i = 1; i <= r; ++i)
        for(int j = 1; j <= c; ++j)
            cin >> a[i][j];
    for(int d = 1+r-1+c-1; ans == 0; ++d)
        dfs(1, 1, 1, d);
    cout << ans;
    return 0;
}