前言
搜索的基本算法分为两种：宽度优先搜索（Breadth-First Search,BFS）以及深度优先搜索（Depth-First Search，DFS）。
在学习过程中我们常常会遇到许多需要用搜索解决的问题。比如迷宫。
一、DFS和BFS
BFS：“全面扩散，逐层递进”
DFS：“一路到底，逐步回退”
这次专题主要是对栈和队列的应用进行分析。所以首先我们先简要描述一下DFS和BFS方便大家对下文的例子有更清晰的认识。
-
BFS（Breadth-First Search）宽度优先搜索
BFS的代码实现可利用队列实现。
从起点开始，一层一层扩散，先处理完离起点近的，再处理它的下一层。根据这个特点可知它与队列先进先出的特点相吻合。使用队列保存未被检测的结点。结点按照宽度优先的次序被访问和进出队列。
同时它也非常符合在图上计算最短路径。很多最短路径算法都是由BFS发展而来的。 -
DFS（Depth-First Search）深度优先搜索
DFS的工作原理则是递归。
而递归和非递归的转换又可依靠栈进行。所以DFS可以使用栈实现。
二、迷宫问题
1.题目描述
- 描述
一个迷宫由R行C列格子组成，有的格子里有障碍物，不能走；有的格子是空地，可以走。
有一个人位于左上角（1,1）处，每次可以向上，下，左，右任意一个方向移动一个单位
给定一个迷宫，求从左上角走到右下角需要走多少步。 - 输入
第一行是两个整数，Ｒ和Ｃ，代表迷宫的长和宽。（ 1<= R，C <= 40)
接下来是Ｒ行，每行Ｃ个字符，代表整个迷宫。
空地格子用’.‘表示，有障碍物的格子用’#‘表示。
迷宫左上角和右下角都是’.'。即要求从左上角走到右下角
假设案例为下图5*5的迷宫
2.BFS(队列)解决
-
分析
用BFS的思想来分析这道题。
当我们每到达一个点的时候都朝四个方向判断其是否能走。这样循环反复，不仅能找到迷宫的出口，同时这个时候所走过的路径也是最短的。
队列的原理时先进先出（FIFO），而BFS类似于树的层次遍历，从离根结点最近的点开始向下扩散。所以我们需要用队列将最先访问的点先存入，先丢出。 -
伪代码实现
-
代码实现如下：
#include<bits/stdc++.h>
using namespace std;
int flag[11][11];//全局变量初始值为0，标记
int x1[4]={0,1,0,-1};//向右，向下,向左，向上
int y2[4]={1,0,-1,0};
int r,c,bex=1,bey=1;//最开始的坐标
char a[44][44];
struct point
{
int x,y,step;
};
void bfs();
int main()
{
cin>>r>>c;
for(int i=1;i<=r;i++)
{
for(int j=1;j<=c;j++)
cin>>a[i][j];
}
bfs();
}
void bfs()
{
queue<point> q;//用来存放可以走的坐标
struct point begin;
begin.x=bex;
begin.y=bey;
begin.step=1;
flag[begin.x][begin.y]=1;
q.push(begin);
while(!q.empty())
{
int x,y,step;
x=q.front().x;
y=q.front().y;
step=q.front().step;
printf("第%d步:(%d,%d)\n",step,x,y);
if(x==r&&y==c)
{
cout<<"总共需要";
cout<<q.front().step<<"步";
break;
}
for(int i=0;i<4;i++)
{
int wx,wy;
wx=x+x1[i];
wy=y+y2[i];
if(a[wx][wy]=='.'&&flag[wx][wy]==0)//可以走且未被走过
{
struct point ing;
flag[wx][wy]=1;
ing.x=wx;
ing.y=wy;
ing.step=q.front().step+1;
q.push(ing);
}
}
q.pop();
}
}
运行结果：
2.DFS(栈)解决
-
分析
用DFS思想分析。
当我们开始走迷宫的时候，每次都往同一个方向行走，直到遇到走不通的，就回退一格往另一个方向试探。
而”回退一格“正是符合栈后进先出的特性。用栈保存所能够到达的每一点坐标。同时可知DFS的实现类似于递归，而栈可以进行非递归的转换.
遵循右->下->左->上的顺序进行探索。 -
伪代码：
代码实现如下）：
#include<bits/stdc++.h>
using namespace std;
int flag[11][11];//全局变量初始值为0，标记
int x1[4]={0,1,0,-1};//向右，向下,向左，向上
int y2[4]={1,0,-1,0};
int r,c,bex=1,bey=1;//最开始的坐标
char a[44][44];
struct point
{
int x,y,direction;
};
stack<point> s;
void dfs();
void print();
int main()
{
cin>>r>>c;
for(int i=1;i<=r;i++)
{
for(int j=1;j<=c;j++)
cin>>a[i][j];
}
dfs();
print();
}
void dfs()
{
int di=0;
point begin;
begin={1,1,-1};
flag[1][1]=1;
s.push(begin);
while(!s.empty())//栈不为空时
{
int x,y,tx,ty;//tx,ty存储实时坐标;
x=s.top().x;
y=s.top().y;
di=s.top().direction+1;
s.pop();
while(di<4)
{
tx=x+x1[di];
ty=y+y2[di];
if(flag[tx][ty]==0&&a[tx][ty]=='.')
{
flag[tx][ty]=1;
point now;
now={x,y,di};
s.push(now);
x=tx,y=ty;//更新坐标
if(x==r&&y==c)
{
now={x,y,di};
s.push(now);
return;
}
else
di=0;//继续沿着之前的路走
}
else di++;//换方向
}
}
}
void print()
{
int i=0;
point p[1000];
while(!s.empty())
{
p[i++]=s.top();
s.pop();
}
for(int j=i-1;j>=0;j--)
{
printf("(%d,%d)\n",p[j].x,p[j].y);//最后在栈中的点
}
}
运行结果
实验总结
- 针对迷宫问题，我们可以根据题目的要求来选择BFS或者DFS来解决，如下图演示。
- BFS实现迷宫问题的具体路线：
- DFS实现迷宫问题的具体路线（绿色为正确路线，黄色为回退）：
- 迷宫问题中的适用场景
- BFS 适用场景
最短路径需求：如逃生路线规划、机器人导航等需要最优解的场景。
稀疏迷宫：通道较少时，BFS 的层序扩展效率更高。
内存充足：适合处理宽而浅的迷宫结构。 - DFS 适用场景
路径探索：如游戏地图生成、所有可能路径枚举。
内存受限：适合处理窄而深的迷宫结构（如树状结构）。
启发式搜索：与剪枝策略结合（如迭代加深 DFS）。
- 两种算法的对比：
时间复杂度：大多数情况下，两者的是时间复杂度差不多，需要搜索整个空间。
空间复杂度：DFS使用的空间往往比BFS大 。因为它需要把走过的结点存起来。 - 性能优化策略
- BFS 优化
双向 BFS：同时从起点和终点出发，相遇时停止，时间复杂度降为 O (√n)。
优先队列：结合启发式函数（如 A * 算法），更快找到最优解。 - DFS 优化
迭代加深 DFS（IDDFS）：限制搜索深度，平衡空间与时间。
记忆化搜索：缓存中间结果，避免重复计算。
- 常见误区与澄清
- 空间复杂度误区：
DFS 的空间复杂度通常为 O (深度)，而 BFS 为 O (宽度)。在迷宫中，若通道分布均匀，BFS 可能更耗内存；若迷宫呈树状，DFS 更耗内存。 - 最短路径误区：
BFS 保证找到最短路径，但 DFS 无法保证。若需最短路径，必须结合额外条件（如路径长度限制）。 - 路径记录误区：
BFS 可在搜索过程中自然生成所有最短路径，而 DFS 需回溯记录所有路径，时间与空间开销更大。
扫一扫
893
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
