欢迎来到我的频道 [【点击跳转专栏】]
作者说:我想说 基础 不等于 简单 ;算法能力不是一蹴而就的,而是来自日积月累的积累和练习!积小流终成江海,诸君 加油!!
文章目录
1. BFS介绍
宽度优先搜索的过程中,每次都会从当前点向外扩展⼀层,所以会具有⼀个最短路的特性。因此,宽搜不仅能搜到所有的状态,⽽且还能找出起始状态距离某个状态的最⼩步数。
但是,前提条件是每次扩展的代价都是 1,或者都是相同的数。 宽搜常常被⽤于解决边权为1 的最短路问题。
即 BFS 是一层一层往外扫,第一层是起点(步数 0)、第二层是走 1 步能到的点、第三层是走 2 步能到的点,依次类推。
关于树的宽度遍历 如果不记得的可以 参考我以前的博客【点击转跳】
2. BFS
2.1 ⻢的遍历(经典模版例题)
https://www.luogu.com.cn/problem/P1443

解法:直接按照马的跳跃规则,模拟马的跳跃即可,即 从起点开始,⼀层⼀层的往外搜,⽤⼀个 dist 数组记录最短距离
关于如何模拟马的走路,可以用两个数组来模拟:
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> PII;
const int N = 410;
int dist[N][N]; // dist[i][j]:起点到(i,j)的最少步数,-1代表不可到达
int n,m,x,y; // n行m列,起点坐标(x,y)
// 马的8个方向:日字走法
int dx[]={1,2,2,1,-1,-2,-2,-1};
int dy[]={2,1,-1,-2,-2,-1,1,2};
void bfs()
{
memset(dist,-1,sizeof(dist)); // 初始化所有点距离为-1(未访问)
queue<PII> q; // BFS队列,存储坐标
q.push({x,y});
dist[x][y]=0; // 起点到自己距离为0
while(q.size())
{
auto t = q.front(); // 取出队首元素
q.pop();
// 枚举8个方向
for(int k=0;k<8;k++)
{
int i=t.first+dx[k],j=t.second+dy[k];
// 越界判断
if(i<1||i>n||j<1||j>m)
{
continue;
}
// 已经访问过,跳过
if(dist[i][j]!=-1)
{
continue;
}
dist[i][j]=dist[t.first][t.second]+1; // 更新步数
q.push({i,j}); // 入队
}
}
}
int main()
{
cin>>n>>m>>x>>y;
bfs();
// 按行输出每个点的最短距离
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
cout<<dist[i][j]<<" ";
}
cout<<endl;
}
return 0;
}
2.2 kotori和迷宫(马的遍历的进阶题)
https://ac.nowcoder.com/acm/problem/50041

讲解算法原理:没啥好说的 太经典了 一次bfs即可!难的就是代码能力了
#include<bits/stdc++.h>
using namespace std;
const int N =35;
typedef pair<int, int> PII;
char a[N][N]; // 存地图
int dist[N][N]; // dist[i][j]:起点到(i,j)的最短距离,-1代表不可达
int n,m,x,y; // n行m列,(x,y)是起点k的坐标
// 上下左右四个方向
int dx[]={1,-1,0,0};
int dy[]={0,0,1,-1};
void bfs()
{
memset(dist, -1, sizeof(dist)); // 距离初始化为-1(未访问)
queue<PII> q;
q.push({x,y});
dist[x][y]=0; // 起点距离为0
while(q.size())
{
auto t = q.front();
q.pop();
int i = t.first;
int j = t.second;
// 枚举4个方向
for(int k=0;k<4;k++)
{
int x= i+dx[k];
int y= j+dy[k];
// 边界合法、不是墙*、还没访问过
if(x>=1&&x<=n&&y>=1&&y<=m&&a[x][y]!='*'&&dist[x][y]==-1)
{
dist[x][y]=dist[i][j]+1;
// 如果走到终点e,只记录距离,不继续入队扩展(终点不能走出去)
if(a[x][y]=='e')
{
continue;
}
q.push({x,y});
}
}
}
}
int main()
{
cin>>n>>m;
// 读入地图,找到起点k
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
cin>>a[i][j];
if(a[i][j]=='k')
{
x=i,y=j;
}
}
}
bfs();
int cnt = 0,ret=1e8;
// 遍历所有终点e,统计能到达的数量、最近距离
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
if(a[i][j]=='e'&&dist[i][j]!=-1)
{
cnt++;
ret=min(ret,dist[i][j]);
}
}
}
if(cnt==0)
{
cout<<-1<<endl;
}
else
{
cout<<cnt<<" "<<ret<<endl;
}
return 0;
}
2.3 Catch That Cow(树的bfs)
https://www.luogu.com.cn/problem/P1588

第一反应肯定是 考虑使用贪心,但是各种策略都能很容易写出反例:
所以我们使用暴搜的方法: 因为我们这道题要找的是最优解,所以我们可以一层一层的将其扩出来,即 使用
bfs。
关于如何剪枝: 当出现前面一个重复过的数字 直接删除即可
#include<bits/stdc++.h>
using namespace std;
const int N =1e5+10;
int dist[N]; // dist[i]:走到i位置的最短步数,-1代表未访问
int t,x,y; // t:测试组数;x:起点;y:终点
int n=1e5; // 坐标上限,防止越界
void bfs()
{
memset(dist,-1,sizeof(dist)); // 初始化所有点为未访问
queue<int> q;
q.push(x); // 起点入队
dist[x]=0; // 起点步数为0
while(q.size()) // 队列不为空就继续搜索
{
int t=q.front(); // 取出队首当前位置
q.pop();
int a=t+1, b=t-1, c=t*2; // 三个转移:+1、-1、*2
// 走+1,不越界且没访问过
if(a<=n&&dist[a]==-1)
{
dist[a]=dist[t]+1;
q.push(a);
}
// 走-1,b>0 且没访问过
if(b>0&&dist[b]==-1)
{
dist[b]=dist[t]+1;
q.push(b);
}
// 走*2,不越界且没访问过
if(c<=n&&dist[c]==-1)
{
dist[c]=dist[t]+1;
q.push(c);
}
// 三个方向任意一个到达终点,直接提前退出bfs
if(a==y||b==y||c==y)
{
return;
}
}
}
int main()
{
cin>>t;
while(t--)
{
cin>>x>>y;
bfs();
cout<<dist[y]<<endl;
}
return 0;
}
2.4 ⼋数码难题(维度转化技巧)
https://www.luogu.com.cn/problem/P1379

经过之前那么多题的铺垫,这道题的解法还是容易想到的。因为要求的是最短步数,因此可以⽤
bfs解决:
算法原理虽然容易,但是实现起来⽐较⿇烦,我们要想办法处理下⾯⼏件事情:
- 如何记录⼀个 3 × 3 的棋盘?
可以⽤字符串。从上往下,从左往右将棋盘内的数依次存到⼀个字符串⾥,来标记棋盘的状态。
- 如何记录最短路?
可以⽤
unordered_map < string,int > dist来标记最短距离,当遍历出现重复步骤时,还可以进行剪枝。
- 如何通过⼀个字符串找到交换之后的字符串?( 本题难点 )
法1:
但是这么做 会在空间和时间上有不小开销 不推荐!
法2: 直接利用数学技巧进行维度转化(该技巧以后可以推广到
n*m的二维数组!!):
#include<bits/stdc++.h>
using namespace std;
// 目标状态:3×3八数码的最终布局
string aim="123804765";
// dist:记录每个状态字符串到达的最少步数,key=状态串,value=步数
unordered_map<string,int> dist;
// 初始输入状态
string s;
// 上下左右四个方向偏移量
int dx[]={1,-1,0,0};
int dy[]={0,0,1,-1};
void bfs()
{
queue<string> q;
// 起点入队
q.push(s);
// 初始状态步数为0
dist.insert({s,0});
while(q.size())
{
// 取出队首状态
string t = q.front();
q.pop();
// 找到数字0所在的一维下标
int pos =0;
while(t[pos]!='0')
{
pos++;
}
// 一维下标转为3*3棋盘的二维坐标(行、列)
int x=pos/3,y=pos%3;
// 遍历4个方向,尝试交换
for(int k=0;k<4;k++)
{
int a=x+dx[k],b=y+dy[k];
// 越界判断,棋盘只有0~2行、0~2列
if(a<0||a>2||b<0||b>2)
{
continue;
}
// 新位置转回一维下标
int npos=a*3+b;
// 复制当前状态,交换0和相邻数字,得到新状态
string nt=t;
swap(nt[npos],nt[pos]);
// 这个状态已经访问过,跳过
if(dist.count(nt))
{
continue;
}
// 新状态入队,步数+1
q.push(nt);
dist.insert({nt,dist[t]+1});
// 已经搜到目标状态,直接结束BFS
if(dist.count(aim))
{
return;
}
}
}
}
int main()
{
// 读入初始状态字符串
cin>>s;
bfs();
// 输出到达目标的最少步数
cout<<dist[aim]<<endl;
}
3. 多源 BFS
- 单源最短路问题 vs 多源最短路问题
- 当问题中只存在一个起点时,这时的最短路问题就是单源最短路问题。
- 当问题中存在多个起点而不是单一起点时,这时的最短路问题就是多源最短路问题。
- 多源BFS
多源最短路问题的边权都为 1 时,此时就可以用多源 BFS 来解决。 - 解决方式
把这些源点汇聚在一起,当成一个"超级源点"。然后从这个"超级源点"开始,处理最短路问题。落实到代码上时:- 初始化的时候,把所有的源点都加入到队列里面;
- 然后正常执行 bfs 的逻辑即可。
也就是初始化的时候,比普通的 bfs 多加入几个起点。
3.1 矩阵距离(模版认识题)
https://ac.nowcoder.com/acm/problem/51024

曼哈顿距离有两种求法:
- 直接按照公式求
- 可以使用最短距离求
法1: 直接模拟进行遍历即可,即每个0节点进行一次
bfs!但是这么做会超时,因为对矩阵遍历是n*m,然后bfs最差情况也是n*m,所以时间复杂度最大是n*n*m*m=1e12!
法2: 正难则反,从0找1难,直接从1找0啊!
即 把所有的1当成一个源点,来一次多源bfs即可!
#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
typedef pair<int,int> PII;
char a[N][N]; // 存地图
int dist[N][N]; // dist[i][j]:(i,j)到最近的'1'的距离
int n,m;
// 上下左右四个方向偏移量
int dx[]={1,-1,0,0};
int dy[]={0,0,1,-1};
void bfs()
{
memset(dist,-1,sizeof(dist)); // 初始距离-1,表示未访问
queue<PII> q;
// 多源BFS:把所有源点(a[i][j]=='1')一次性入队
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
if(a[i][j]=='1')
{
q.push({i,j});
dist[i][j]=0; // 源点到自己距离为0
}
}
}
// BFS循环
while(q.size())
{
auto t=q.front();
q.pop();
int x=t.first,y=t.second; // 当前点坐标
// 遍历4个方向
for(int k=0;k<4;k++)
{
int i=x+dx[k],j=y+dy[k]; // 新坐标
// 边界合法 + 该点还没被访问过
if(i>=1&&i<=n&&j>=1&&j<=m&&dist[i][j]==-1)
{
q.push({i,j});
dist[i][j]=dist[x][y]+1; // 距离 = 当前点距离+1
}
}
}
}
int main()
{
cin>>n>>m;
// 读入地图
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
cin>>a[i][j];
}
}
bfs();
// 输出每个点到最近'1'的距离
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
cout<<dist[i][j]<<" ";
}
cout<<endl;
}
return 0;
}
3.2 刺杀大使(综合题,利用的是bfs的可行性)
https://www.luogu.com.cn/problem/P1902

- 解法一: 找出所有路线,找出其中 最大值最小的情况!此时时间复杂度是
m*n*m=1e9>1e8是会超时的!
- 解法二: 利用
二分答案+bfs判断!为什么会想到二分呢?因为你想想啊 假设我们的答案是
ret是不是如果走比ret小的伤害值,是一定不可能走出迷宫的,而比ret大的伤害值,是不是随便走??这样就可以把答案进行二分了,而二分模版的判定条件不就可以很自然的使用bfs去确认这条路径是否可行吗!这样我们的时间复杂度,不就优化成了logn*n*m=3*1e3*1e3=3e6了吗!
这个代码老实说不好写 可以参考我的注释,然后让帮助ai解读 如果二分忘记了可以参考我以前的博客 【点击转跳】
#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
typedef pair<int,int> PII;
int p[N][N]; // p[i][j]:格子 (i,j) 的伤害值
// 这里不求最短路径,只标记格子走没走过,用 bool 就够了
bool dist[N][N];
int n, m; // n 行 m 列
// 上下左右四个方向偏移量
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
// 伤害上限为 mid 时,判断能否从第一行走到最后一行
bool bfs(int mid)
{
memset(dist, 0, sizeof(dist)); // 每次二分都重新清空访问标记
queue<PII> q;
// 多源 BFS:第一行所有格子同时作为起点入队
for(int j = 1; j <= m; j++)
{
q.push({1, j});
dist[1][j] = true;
}
while(q.size())
{
auto t = q.front();
q.pop();
int x = t.first, y = t.second; // 当前出队的格子坐标
// 只要有一个格子到达最后一行,说明路径走通,直接返回 true
if(x == n) return true;
// 枚举四个方向
for(int k = 0; k < 4; k++)
{
int i = x + dx[k], j = y + dy[k]; // 相邻格子坐标
// 条件:不越界 + 没走过 + 伤害不超过上限 mid
if(i >= 1 && i <= n && j >= 1 && j <= m
&& dist[i][j] == false && p[i][j] <= mid)
{
dist[i][j] = true; // 标记已访问,避免重复入队
q.push({i, j});
}
}
}
return false; // 队列清空仍未到最后一行,走不通
}
int main()
{
cin >> n >> m;
int l = 0, r = 0;
// 读入地图,右端点取所有格子伤害的最大值
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= m; j++)
{
cin >> p[i][j];
r = max(r, p[i][j]);
}
}
// 二分模板:求能走通的最小伤害上限(最小化最大值)
while(l < r)
{
// 向下取整,不需要 +1;本模板找的是最小可行值
int mid = l + (r - l) / 2;
if(bfs(mid))
{
r = mid; // mid 可行,尝试更小的上限
}
else
{
l = mid + 1; // mid 不可行,提高上限
}
}
cout << l << endl; // 二分结束后 l == r,即为答案
return 0;
}
4. 01 BFS(双端队列 BFS)
- 对于普通的
bfs,解决的都是 边权为1的最短路径问题,并且整 体呈现单调不减的趋势!

- 那么什么是
01bfs,就是边的权值既有0也有1!
如果直接这么放,不用想,肯定是错的!
但是如果,咱们将queue换成deque呢?碰到权值
1,咱们正常后方,碰到0,直接前插,把它当成上一个节点的等效节点!
此时E->B,换成以前传统的bfs,因为B已经走过了,就直接不考虑了(剪枝),但是在这里,B的新权值是可能出现更优的情况的!我们用w表示E->B的权值,如果此时dist[E]+w < dist[B],那么就要重新更新新的dist[B]!
该操作我们称为:松弛操作。
01 BFS 又称双端队列 BFS。 在最短路问题中,边权值可能为 1 也可能为 0。那么,在 BFS 的过程中,可以将边权为 0 扩展出来的点放到队首,边权为 1 扩展出来的点放到队尾。这样就能保证像普通 BFS 一样整个队列队首到队尾权值单调不下降。
注意: 不同于普通的 bfs 问题,01bfs 问题在遍历的过程中,如果遇到之前已经遍历过的结点,有可能会找到一条更优的路线。在写代码的时候,要注意判断这一点。
4.1 ⼩明的游戏(模版题)
https://www.luogu.com.cn/problem/P4554

- 如果⾛到相同格⼦,权值为 0 ,更新最短距离,然后加⼊到队头;
- 如果⾛到不同格⼦,权值为 1 ,更新最短距离,然后加⼊到队尾。
⚠️:这道题不关心松弛操作也能解决问题,因为这道题,只要
(i,j)这个点放到队列里面,就一定是最优情况。
这是因为 你无论走多少@->@,只要有一个@->#就必然会权值+1!
当然,这种情况只是特列,这里我们还是按照严格的01bfs模版来写,该模版要熟记!
#include<bits/stdc++.h>
using namespace std;
const int N=510;
typedef pair<int,int> PII;
char a[N][N]; // 存地图(每个格子是一个字符)
int dist[N][N]; // dist[i][j]:起点到 (i,j) 的最小代价,-1 表示未访问
int n,m,sx,ex,sy,ey; // 起点坐标 (sx,sy)、终点坐标 (ex,ey)
int dx[]={1,-1,0,0}; // 上下左右四个方向的行偏移
int dy[]={0,0,1,-1}; // 上下左右四个方向的列偏移
void bfs()
{
memset(dist,-1,sizeof(dist)); // 距离数组全部初始化为未访问
// 起点就是终点,代价为 0
if(ex==sx && ey==sy)
{
dist[ex][ey]=0;
return;
}
deque<PII> dq; // 01BFS 用双端队列
dq.push_back({sx,sy}); // 起点入队尾
dist[sx][sy]=0; // 起点距离为 0
while(dq.size())
{
auto t=dq.front(); // 取出队首节点
dq.pop_front();
int x=t.first, y=t.second; // 当前节点坐标
// 到达终点(注意:01BFS 这里直接 return 有隐患,见文末说明)
if(x==ex && y==ey) return;
for(int k=0;k<4;k++)
{
int i=x+dx[k], j=y+dy[k]; // 相邻节点坐标
// 边权:格子相同代价 0,不同代价 1
int w=(a[i][j]==a[x][y]?0:1);
// 0 下标越界判断
if(i>=0&&i<n&&j>=0&&j<m)
{
// 第一次到达该节点
if(dist[i][j]==-1)
{
dist[i][j]=dist[x][y]+w;
if(w==0) dq.push_front({i,j}); // 0 权边 → 插队头
else dq.push_back({i,j}); // 1 权边 → 插队尾
}
// 找到更短路径,松弛更新距离
else if(dist[x][y]+w < dist[i][j])
{
dist[i][j]=dist[x][y]+w;
}
}
}
}
}
int main()
{
// 多组数据,读到 0 0 结束
while(cin>>n>>m, n&&m)
{
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
cin>>a[i][j];
cin>>sx>>sy>>ex>>ey; // 读入起点、终点坐标
bfs();
cout<<dist[ex][ey]<<endl; // 输出最小代价
}
return 0;
}
4.2 Three States(难题!综合题)
https://www.luogu.com.cn/problem/CF590C

直接找出结果点是很⿇烦的,需要枚举所有的点,然后每个点都要来⼀次 bfs,这样是会超时的。
可以依次从三个国家出发,⽤ bfs 计算出来到达所有点的最短距离。求出所有距离之后,重新遍历所有的点,分情况求出到三个国家的最短距离。
算法原理很简单,但是⾥⾯有很多细节需要注意:
- 因为每个国家可能有很多点,并且国家的点与点之间不连通,因此我们要⽤
多源bfs求某个国家到所有点的最短距离;- 国家与国家之间的点如果相连,它们之间的距离是 0(无论是不是同一个国家,在我们这道题里面,它们的距离都是 0 ,因为都不需要修路)。那么我们这道题里面边的权值要么是 0 ,要么是 1 。因此需要用
01bfs来更新所有的距离;- 计算某一个点到三个国家的最短距离时,应该分情况讨论。设 a , b , c a,b,c a,b,c 分别表示三个国家到该点的最短距离:
- a. 如果该点是一个国家,最短距离为 a + b + c a+b+c a+b+c;
- b. 如果该点是一个荒地,最短距离为 a + b + c − 2 a+b+c-2 a+b+c−2,因为我们计算最短距离的时候,荒地会被计算三次,所以要减去两次。
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> PII; // 坐标对:(行号, 列号)
const int N = 1010; // 网格最大边长
char a[N][N]; // 存储地图:'1'/'2'/'3' 三个起点,'.' 空地,'#' 障碍
int dist[4][N][N]; // dist[起点编号][i][j]:该起点到 (i,j) 的最短距离(编号 1/2/3)
int n, m; // 网格行数 n、列数 m
int dx[] = {1, -1, 0, 0}; // 四个方向:下、上、右、左
int dy[] = {0, 0, 1, -1};
/**
* 01-BFS:从所有字符为 ch 的格子出发,求到地图各点的最短距离
* 边权只有两种:进入空地 '.' 花费 1,进入其他数字格子花费 0
*/
void bfs(char ch)
{
int pos = ch - '0'; // 字符转编号,如 '1' -> 1
memset(dist[pos], -1, sizeof(dist[pos])); // -1 表示尚未访问
deque<PII> q; // 双端队列:0 权边插队首,1 权边插队尾
// —— 多源 BFS:先把该字符的所有格子全部入队 ——
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= m; j++)
{
if (a[i][j] == ch)
{
q.push_back({i, j});
dist[pos][i][j] = 0; // 起点距离为 0
}
}
}
// —— 01-BFS 主循环 ——
while (q.size())
{
auto t = q.front();
q.pop_front();
int i = t.first, j = t.second;
for (int k = 0; k < 4; k++)
{
int x = i + dx[k], y = j + dy[k];
// 越界 或 遇到障碍 '#',跳过
if (x >= 1 && x <= n && y >= 1 && y <= m && a[x][y] != '#')
{
// 进入空地 '.' 权值为 1;进入其他数字格子权值为 0
int w = (a[x][y] == '.' ? 1 : 0);
// 第一次到达该节点
if (dist[pos][x][y] == -1)
{
dist[pos][x][y] = dist[pos][i][j] + w;
// 0 权边放队首,1 权边放队尾,保证队列按距离单调
if (w == 0) q.push_front({x, y});
else q.push_back({x, y});
}
// 松弛操作:找到更短路径,更新距离
else if (dist[pos][i][j] + w < dist[pos][x][y])
{
dist[pos][x][y] = dist[pos][i][j] + w;
}
}
}
}
}
int main()
{
cin >> n >> m;
// 读入地图
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= m; j++)
{
cin >> a[i][j];
}
}
// 分别以 1、2、3 为源点跑三次 01-BFS
bfs('1'), bfs('2'), bfs('3');
int ret = 0x3f3f3f3f; // 答案初始化为无穷大
// 枚举每个汇合点,计算三路到该点的距离之和
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= m; j++)
{
int t1 = dist[1][i][j];
int t2 = dist[2][i][j];
int t3 = dist[3][i][j];
// 任一路径不可达,跳过该点
if (t1 == -1 || t2 == -1 || t3 == -1) continue;
// 汇合点本身是空地 '.' 时,三条路径都计入了该点,重复 3 次需减去 2;
// 汇合点是数字格子时不重复计费,直接求和
if (a[i][j] == '.') ret = min(t1 + t2 + t3 - 2, ret);
else ret = min(t1 + t2 + t3, ret);
}
}
// 全部不可达,输出 -1
if (ret == 0x3f3f3f3f) ret = -1;
cout << ret << endl;
return 0;
}
⚠️:该题在洛谷无法提交,需要进入原题目注册账号并进行提交:
















2525



被折叠的 条评论
为什么被折叠?



