迷宫问题(BFS)

本文详细解析了一道迷宫问题的最短路径求解算法,使用BFS(宽度优先搜索)方法,针对多组测试数据,实现从起点到终点的最短路径寻找。介绍了输入输出格式,以及如何利用BFS模板进行代码实现。

题目链接:http://210.41.166.247/problem.php?cid=1020&pid=5

问题 F: 迷宫问题

时间限制: 1 Sec  内存限制: 32 MB
提交: 9  解决: 5
[提交] [状态] [讨论版] [命题人:外部导入]

题目描述

小明置身于一个迷宫,请你帮小明找出从起点到终点的最短路程。
小明只能向上下左右四个方向移动。

 

输入

输入包含多组测试数据。输入的第一行是一个整数T,表示有T组测试数据。
每组输入的第一行是两个整数N和M(1<=N,M<=100)。
接下来N行,每行输入M个字符,每个字符表示迷宫中的一个小方格。
字符的含义如下:
‘S’:起点
‘E’:终点
‘-’:空地,可以通过
‘#’:障碍,无法通过
输入数据保证有且仅有一个起点和终点。

 

输出

对于每组输入,输出从起点到终点的最短路程,如果不存在从起点到终点的路,则输出-1。

 

样例输入

1
5 5
S-###
-----
##---
E#---
---##

 

样例输出

9

解题思路:初略的扫了一下题面,就大概知道这道题是一道搜索题。而且典型的板子题。这是我们比赛时的一道题,因为行列上限是100。比赛时为了保险怕爆栈,所以我用的是BFS来做的,而且题目本身要求求出最短路径,所以用bfs来做也比较合理。与bfs的模板没有太大差异和变化。所以按着思路来写就可以了。用一个标志flag,找到目标就更新flag,然后return。若flag未更新,则未找到该目标。

AC代码:

#include<cstdio>
#include<queue>
#include<algorithm>
using namespace std;
char m[110][110];
int M[4][2] = {1, 0, 0, 1, -1, 0, 0, -1};
int in;
int flag;
int n, z;
struct pos{
    int x;
    int y;
    int num;
};
void bfs(int i, int j)
{
    int di, dj;
    int k;
    pos e, t;
    queue<pos> ans;
     e.x = i;
     e.y = j;
     e.num = 0;
    ans.push(e);    
    while(!ans.empty())
    {
        e = ans.front();
 
        ans.pop();
        for(k = 0; k < 4; ++k)
        {
            di = e.x + M[k][0];
            dj = e.y + M[k][1];
            if(di >= 0 && di < n && dj >= 0 && dj < z && m[di][dj] != '#')
            {
                if(m[di][dj] == 'E') 
                {
                    flag = 1;
                    in = e.num + 1;
                    return;
                }
 
                    t.x = di;
                    t.y = dj;
                    t.num = e.num + 1;
                    ans.push(t);
                m[di][dj] = '#';
            }
        }
    }   //printf("%d %d\n", e.x, e.y);
}
int main()
{
    int t;
    int i, j;
 
    scanf("%d", &t);
    while(t--)
    {
        flag = 0;
        scanf("%d%d", &n, &z);  
        for(i = 0; i < n; ++i)
        {
            scanf("%s", m[i]);
        }
        for(i = 0; i < n; ++i)
            for(j = 0; j < z; ++j)
            {
                if(m[i][j] == 'S')
                {
                    bfs(i, j);
                    break;
                }
            }
    if(flag)
        printf("%d\n", in);
    else
        printf("-1\n");
 
    }
    return 0;
}

 

使用广度优先搜索(BFS)和深度优先搜索(DFS)解决迷宫问题是常见的图搜索算法应用。 ### BFS解决迷宫问题 BFS采用逐层扩展的方式,先访问当前节点的所有邻居节点,再逐层向外扩展,适合搜索最短可路径,且第一次找到的可解一定是最短路径 [^2][^4]。 解决步骤如下: 1. 定义迷宫类,包含迷宫数、列数和一个二维的字符数组表示迷宫。 2. 实现`bfs`函数,用于进广度优先搜索,以找到从起点到终点的路径。 3. 在`main`函数中,创建一个迷宫对象,并调用`bfs`函数来解决迷宫问题。 示例代码如下: ```python from collections import deque # 定义迷宫类 class Maze: def __init__(self, rows, cols, maze): self.rows = rows self.cols = cols self.maze = maze def bfs(self, start, end): # 定义四个方向:上、下、左、右 directions = [(-1, 0), (1, 0), (0, -1), (0, 1)] # 初始化队列 queue = deque([(start, [start])]) # 记录已访问的节点 visited = set([start]) while queue: (x, y), path = queue.popleft() if (x, y) == end: return path for dx, dy in directions: new_x, new_y = x + dx, y + dy if 0 <= new_x < self.rows and 0 <= new_y < self.cols and self.maze[new_x][new_y] == 0 and (new_x, new_y) not in visited: new_path = path + [(new_x, new_y)] queue.append(((new_x, new_y), new_path)) visited.add((new_x, new_y)) return None # 示例迷宫 maze = [ [0, 1, 0, 0, 0], [0, 1, 0, 1, 0], [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 0, 0, 1, 0] ] m = Maze(5, 5, maze) start = (0, 0) end = (4, 4) path = m.bfs(start, end) if path: print("最短路径:", path) else: print("未找到路径") ``` ### DFS解决迷宫问题 DFS是一种递归的搜索算法,其核心思想是沿着一个分支尽可能深入地搜索,直到达到最深的节点,然后再回溯到上一层,继续探索其他分支,适合搜索所有的可路径,但第一次找到的可解不一定是最短路径 [^2][^4]。 解决步骤如下: 1. 定义迷宫的二维数组。 2. 实现`dfs`函数,用于进深度优先搜索。 3. 在`main`函数中,调用`dfs`函数来解决迷宫问题。 示例代码如下: ```python # 定义迷宫 maze = [ [0, 1, 0, 0, 0], [0, 1, 0, 1, 0], [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 0, 0, 1, 0] ] rows = 5 cols = 5 start = (0, 0) end = (4, 4) # 记录所有可路径 all_paths = [] def dfs(x, y, path, visited): if (x, y) == end: all_paths.append(path[:]) return directions = [(-1, 0), (1, 0), (0, -1), (0, 1)] for dx, dy in directions: new_x, new_y = x + dx, y + dy if 0 <= new_x < rows and 0 <= new_y < cols and maze[new_x][new_y] == 0 and (new_x, new_y) not in visited: path.append((new_x, new_y)) visited.add((new_x, new_y)) dfs(new_x, new_y, path, visited) path.pop() visited.remove((new_x, new_y)) visited = set([start]) dfs(start[0], start[1], [start], visited) if all_paths: shortest_path = min(all_paths, key=len) print("最短路径:", shortest_path) else: print("未找到路径") ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值