搜索算法详解(2)宽度优先搜索 - BFS 算法详解

宽度优先搜索算法(BFS) 先从左向右,再从右向左地对每一层节点进行遍历以示例1为例:即。 阅读详情

欢迎来到我的频道 [【点击跳转专栏】]在这里插入图片描述
作者说:我想说 基础 不等于 简单 ;算法能力不是一蹴而就的,而是来自日积月累的积累和练习!积小流终成江海,诸君 加油!!

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解决:
在这里插入图片描述


算法原理虽然容易,但是实现起来⽐较⿇烦,我们要想办法处理下⾯⼏件事情:

  1. 如何记录⼀个 3 × 3 的棋盘?

可以⽤字符串。从上往下,从左往右将棋盘内的数依次存到⼀个字符串⾥,来标记棋盘的状态。

  1. 如何记录最短路?

可以⽤ unordered_map < string,int > dist 来标记最短距离,当遍历出现重复步骤时,还可以进行剪枝。

  1. 如何通过⼀个字符串找到交换之后的字符串?( 本题难点 )

法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

  1. 单源最短路问题 vs 多源最短路问题
  • 当问题中只存在一个起点时,这时的最短路问题就是单源最短路问题。
  • 当问题中存在多个起点而不是单一起点时,这时的最短路问题就是多源最短路问题。
  1. 多源BFS
    多源最短路问题的边权都为 1 时,此时就可以用多源 BFS 来解决。
  2. 解决方式
    把这些源点汇聚在一起,当成一个"超级源点"。然后从这个"超级源点"开始,处理最短路问题。落实到代码上时:
    1. 初始化的时候,把所有的源点都加入到队列里面;
    2. 然后正常执行 bfs 的逻辑即可。

也就是初始化的时候,比普通的 bfs 多加入几个起点。

3.1 矩阵距离(模版认识题)

https://ac.nowcoder.com/acm/problem/51024
在这里插入图片描述

曼哈顿距离有两种求法:

  1. 直接按照公式求
  2. 可以使用最短距离求
    在这里插入图片描述

法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
请添加图片描述

  1. 解法一: 找出所有路线,找出其中 最大值最小的情况!此时时间复杂度是m*n*m=1e9>1e8是会超时的!

  1. 解法二: 利用 二分答案+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;
}

⚠️:该题在洛谷无法提交,需要进入原题目注册账号并进行提交:
在这里插入图片描述
请添加图片描述

图搜索算法——宽度优先算法BFS、最短路径算法Dijkstra、A*、Hybrid A* BFS、Dijkstra、A*、Hybrid A*1、符号说明2、宽度优先搜索BFS3、Dijkstra 算法4、A*算法5、Hybrid A*算法5.1 Hybrid A*的与众不同之处5.2 Hybrid A*的实现5.2.1 搜索 做个正直的人 1、符号说明 C:closed list,里面存储的是所有已经处理过的节点 O:open list,里面存储的是所有已经发现但是还没有被放进closed list中的节点 U(x):表示所有可以对x采取的动作的集合,其返回结果是x的相邻节点 predecess 阅读详情

相关推荐

c++宽度优先搜索BFS

宽度优先搜索,又叫做广度优先搜索,简称宽搜(BFS),是另一种常见搜索算法(还有一种是深搜)。宽搜是一种图的搜索算法,运用非常广泛,也很基础,是每一个编程者必学的算法。因为它是一个很便捷的算法,可拓展性也很高。一些图的最短路算法基本上都是用的是宽搜,或者是基于宽搜。比如Dijstra(求单源最短路径的),和Prim(最小生成树)。这两个都是比较进阶一点的算法,只有把宽搜学扎实了,才有拓展的可能。总之,宽搜必学!

zhaoniuniu0309的博客,刚刚开始写博文的新手,有不对的地方请谅解。 2525

宽度优先搜索算法(BFS)详解(超级详细讲解,附有大图)

​ 补充说明:由上可以知道,广度优先搜索的特征为从起点开始,由近及远进行广泛的搜索。因此,目标顶点离起点越近,搜索结束得就越快。 三.对比与发现 DFS和BFS的区别 bfs 遍历节点是先进先出,dfs遍历节点是先进后出; bfs是按层次访问的,dfs 是按照一个路径一直访问到底,当前节点没有未访问的邻居节点时,然后回溯到上一个节点,不断的尝试,直到访问到目标节点或所有节点都已访问。 bfs 适用于求源点与目标节点距离最近的情况,例如:求最短路径。dfs 更适合于求解一个任意符合方案中的一个或者遍历所有情

aliyonghang的博客 5万+

宽度优先搜索算法

其中有一些人相互认识,现在 x 想要认识 y,可以通过他所认识的人来认识更多的人(如果 a 认识 b、b 认识 c,那么 a 可以通过 b 来认识 c),求出 x 最少需要通过多少人才能认识 y。以下为一个 w 行 h 列的二维字符矩阵,每个字符为“.”“#”“@”,分别表示该位置为黑色的瓷砖、红色的瓷砖、小林的初始位置。对于以上“无向图”,从顶点 V0 开始进行宽度优先搜索,得到的一个序列为 V0,V1,V2,V3,V4,V6,V5。【输出格式】 输出一行一个数,表示 x 认识 y 最少需要通过的人数。

weixin_43694660的博客 1016

BFS(宽度优先算法)

1.BFS简介 宽度优先搜索算法(又称广度优先搜索)是最简便的图的搜索算法之一,这一算法也是很多重要的图的算法的原型。其别名又叫BFS,属于一种盲目搜寻法,目的是系统地展开并检查图中的所有节点,以找寻结果。换句话说,它并不考虑结果的可能位置,彻底地搜索整张图,直到找到结果为止。简单来说,bfs好像是一个耳听六路眼观八方的人,搜索时是一层一层的搜索的。BFS利用的数据结构是queue,空间复杂度为o(2^n),另外BFS可以用来解决最短路问题。BFS是一个从近到远的扩散过程。 2.基本思想 ...

zgdlxs的博客 1万+

宽度优先搜索算法BFS

寒假集训第二期所学知识总结1. 栈1.1典型题型1.2解法1.2.1后缀表达式求值1.2.2中缀表达转换成后缀表达式1.2.3字符串匹配问题1.2.4中缀表达式值 1. 栈 1.1典型题型 中(后)缀表达式的计算, 转化. 括号匹配 模拟(如 车厢调度) 1.2解法 1.2.1后缀表达式求值 题目大意: 给出一个仅由整数 、+、-、*、/等组成的后缀表达式,符号之间用空格分开,计算它的值。 思路 : 建一个栈记录读入的数, 遇到运算符就取出栈顶两个元素进行计算, 再把结果压入栈.最后输出栈顶元素.(注意:

A_box_of_yogurt的博客 942

搜索算法(DFS,BFS等)

文章目录搜索算法及练习题1. 搜索算法概述2. 宽度优先搜索(Breadth First Search,BFS)2.1 Robot in Maze2.2 Yet Another Multiple Problem2.3 马的遍历2.4 Fire!3. 深度优先搜索(Depth First Search,DFS)3.1 八皇后问题3.2 迷宫3.3 奇怪的电梯3.4 [NOIP2017 提高组] 奶酪3.5 [USACO05DEC]Scales S3.6 油田(连通块)4. 剪枝4.1 小木棍 [数据加强版]4

林景的博客 1705

经典搜索算法总结

前言0x01 搜索问题的形式化0x02 树搜索和图搜索0x03 搜索算法的评估0x04 盲目搜索算法0x04.01 宽度优先搜索算法BFS0x04.02 一致代价搜索算法UCS0x04.03 深度优先搜索算法DFS 前言 搜索问题是在解决各类问题时不可避免的重点难点,很多问题的求解过程都可以转变为搜索问题。比如,对于以下罗马尼亚问题,希望找到一条路径使得从城市 Arad 到城市 Bucuresti 的路径最短,这就是一个经典的搜索问题,在数据结构课程中,我们都知道使用 Dijkstra 算法来求得最优解,.

qq_21746331的博客 1万+

WRF和WPS模型在Ubuntu系统上的安装与常见问题解决指南

本文详细介绍了在Ubuntu系统上安装WRF和WPS模型的完整教程,涵盖系统环境配置、依赖库安装、源代码编译以及常见问题的解决方案。重点解决了WPS编译中intmath.f文件的修改、环境变量设置和编译器兼容性等关键难点,帮助用户高效部署气象研究与预报模型。

weixin_29213525的博客 382

BFS算法(宽度优先搜索)超强解析 BFS迷宫问题图文详解 DFS与BFS的区别

详解bfs算法,以及dfs,bfs的区别,以迷宫为例题。

2301_79599253的博客 2859

vue 获取el-table多选的选中行

<el-table :data='tableData' ref="multipleTable" v-loading='loading' border max-height='700' style='width: 100%' size="mini"> <el-table-column type="selection" width="55"></el-table-column> <el-table-column label

且听风吟的博客 6650

发那科机器人Modbus通讯配置全攻略:从IP设置到信号调试

本文详细介绍了发那科机器人Modbus通讯的配置方法,从基础认知到IP设置、端口配置、信号调试及故障排查。重点讲解了UOP和DI/DO信号的配置技巧,帮助工程师快速实现机器人与PLC的稳定通讯,提升自动化系统效率。

weixin_27872611的博客 627

BFS搜索算法

BFS 全称是,中文名是宽度优先搜索,也叫广度优先搜索。是图上最基础、最重要的搜索算法之一。所谓宽度优先。就是每次都尝试访问同一层的节点。如果同一层都访问完了,再访问下一层。这样做的结果是,BFS 算法找到的路径是从起点开始的合法路径。换言之,这条路径所包含的边数最小。在 BFS 结束时,每个节点都是通过从起点到该点的最短路径访问的。我们来构造一个例子,使用bfs和restore函数,演示如何在一个无向图中找到最短路径12421353264155246635我们希望从起点节点1。

ke_wu的博客 1628

利用Matlab绘制非线性系统相图:从理论到实践

本文详细介绍了如何利用Matlab进行非线性系统的相图绘制与相平面分析。从理论基础的状态空间转换出发,通过无阻尼线性谐振子和范德波尔振荡器等实例,手把手演示了使用ode45求解器绘制相图、分析平衡点与极限环的完整流程,并分享了方向场绘制、参数分岔探索及常见错误解决方案等高级技巧,为动力学系统分析与控制设计提供了直观强大的可视化工具。

yhn456789的博客 909

Python实现深度优先与宽度优先搜索算法

文章转载处:https://blog.csdn.net/qq_40276310/article/details/80668401 一、算法原理 首先,我们给定一个二叉树图如下: 1、宽度优先搜索: 宽度优先搜索算法(Breadth First Search,BSF),思想是: 从图中某顶点v出发,首先访问定点v 在访问了v之后依次访问v的各个未曾访问过的邻接点; 然后分别从这些邻接点出发依次访...

zhuyunier的博客 8154

SIMATIC WINCC V8.0安装教程(Win11系统)

SIMATIC WINCC V8.0安装教程(Win11系统)

Robot_PLC_HMI_Automation 9066

Git下载与安装

一、Git下载 二、Git安装

欢迎订阅我的“JAVA全栈开发笔记(全)”专栏,价格优惠,仅需19.9元。 6万+

六大搜索算法

宽度优先搜索算法BFS题目描述图信息存储树的构建以及图的实现代码无信息搜索策略宽度优先搜索算法BFS 题目描述 使用搜索算法实现罗马尼亚问题的求解 1:创建搜索树; 2:实现搜索树的宽度优先搜索,深度优先搜索,一致代价搜索,迭代加深的深度优先搜索算法; 3:实现贪婪最佳优先搜索和A*搜索 4:使用编写的搜索算法代码求解罗马尼亚问题; 5:记录各种算法的时间复杂度并绘制直方图 图信息存储 树的构建以及图的实现代码 搜索树中的树结点定义: 在搜索树中,每一个树结点应该记录的信息包括: 该树结点的代价估计

m0_45020051的博客 4705

080、多轴运动控制:插补器设计(螺旋线插补)

本文分享了螺旋线插补器设计的实战经验。针对五轴点胶机Z轴抖动问题,作者分析了螺旋线数学本质,提出基于归一化时间参数的速度规划方法,强调各轴严格同步的重要性。文章详细介绍了速度分解、加减速处理、嵌入式优化技巧(查表法、定点化),并总结了起点闭合、速度波动、数值处理等常见问题解决方案。最后给出5条实用建议:注重速度规划而非纯数学推导、预先仿真、保留调试接口、考虑机械谐振、防范编码器丢脉冲。通过优化插补周期、电子齿轮比和S形速度曲线,成功将设备良率从60%提升至95%。

m0_50546716的博客 89

宽度优先搜索算法实现8数码_经典搜索算法总结

本文内容主要来自Artificial Intelligence A Modern Approach和Stanford CS221。人工智能可以被建模成:学习,模型,推断。所谓的搜索往往指的是根据模型推断的过程。本文的内容主要包括搜索算法的背景和定义无信息搜索算法宽度优先搜索BFS统一代价搜索UCS深度优先搜索DFS深度受限搜索DLS迭代加深搜索IDS双向搜索BS有信息搜索算法贪心搜索A* 搜索迭代...

weixin_28877505的博客 1577

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

C++宽度优先搜索算法:队列与优先级队列

public:// 创建一个大根堆(优先级队列默认是最大堆)// 这意味着队列顶部始终是当前最大的元素// 将所有石头重量加入优先级队列q.push(x);// 循环处理,直到队列中只剩下一块石头或没有石头// 取出当前最重的石头q.pop();// 取出当前第二重的石头q.pop();// 如果两块石头重量不相等,将差值重新加入队列if(a > b)// 如果相等,两者都粉碎,不需要操作(相当于都不加入队列)

2401_89119815的博客 1331

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

宽度优先搜索

自然界中的宽搜BFS,其英文全称是Breadth First Search。BFS并不使用经验法则算法。从算法的观点,所有因为展开节点而得到的子节点都会被加进一个先进先出的队列中。一般的实验里,其邻居节点尚未被检验过的节点会被放置在一个被称为 open 的容器中(例如队列或是链表),而被检验过的节点则被放置在被称为 closed 的容器中。(open-closed表)在证明宽度优先搜索的各种性质之前,我们先做一些相对简单的工作 ——分析算法在图G=(V,E)之上的运行时间。

2301_76841790的博客 1517

算法学习笔记:宽度优先搜索(BFS)

算法学习笔记:宽度优先搜索(BFS) 宽度优先搜索算法(又称广度优先搜索)是最简便的图的搜索算法之一,这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS,属于一种盲目搜寻法,目的是系统地展开并检查图中的所有节点,以找寻结果。换句话说,它并不考虑结果的可能位置,彻底地搜索整张图,直到找到结果为止。 广度优先...

ccystewart的博客 3139

【数据结构】一文搞懂宽度优先算法:原理、实现与应用

本文系统介绍了宽度优先算法(BFS)的原理、实现及应用。BFS是一种基于队列的图遍历算法,其核心思想是逐层扩展搜索范围,确保找到最短路径。文章首先通过迷宫寻路的类比阐释BFS的工作原理,并与深度优先算法(DFS)进行对比;随后详细讲解Python实现步骤,包括图结构表示、队列应用等;最后展示BFS在迷宫寻路、社交网络分析和网页爬虫中的实际应用案例。文章指出BFS具有路径最优性等优势,但也存在内存消耗大的局限性,并探讨了与启发式算法结合、分布式优化等未来发展方向。

大雨淅淅的博客 1232

搜索算法 BFS DFS & IDS

在AlphaGo击败人类棋手、惊艳全球的背后,搜索算法作为早期人工智能的‘宠儿’,不仅没有沉寂,反而在算力的加持下进化成了更强大的形态。本文将带大家回顾人工智能的基石——几种主流的无信息搜索算法,看看它们如何像探路者一样,在未知的状态空间中寻找答案。

top_pioneer的博客 1039
上一篇: MySQL数据库(9)表的内连和外连
下一篇: 搜索算法详解(3)Floodfill 问题
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值