【基础算法总结】BFS_多源最短路问题

最新推荐文章于 2024-11-01 17:00:11 发布
最新推荐文章于 2024-11-01 17:00:11 发布
阅读量1k 收藏 86
点赞数 112
分类专栏： 经典算法专栏 文章标签： 算法 宽度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77900444/article/details/141292603
版权

目录

1. 算法介绍

所谓多源，就是有多个起点。对应上一篇文章【BFS_最短路问题】的单源问题。这篇文章介绍用bfs解决边权为1(或边权相等)的多源最短路问题。

我们解决单源问题时，是先把起点入队列，再一层一层向外扩展。而多源问题是：把所有源点当成一个"超级源点"，把"超级源点"加入到队列，再一层一层向外扩展，就变成单源问题了。
在这里插入图片描述

如何把所有源点当成"超级源点"？
通过介绍下面的四道题目将给出答案。

2. 算法原理和代码实现

542.01矩阵

在这里插入图片描述
在这里插入图片描述

算法原理：

解法一：暴力求解。每个位置都用一次bfs计算出到最近0的距离，这毫无疑问会超时。

解法二：多源bfs+正难则反。
把所有的0当成起点，1当成终点。先把所有的0位置加入到队列中，再一层一层扩展即可。同时要创建一个与原矩阵等规模的dist矩阵，用来记录距离。
在这里插入图片描述

细节/技巧问题：

我们可以回想一下在解决单源最短路问题时，我们定义了一个bool类型的数组vis用来标记该位置是否被遍历过，最少步数step表示扩展层数，每次出队列的个数sz。

但是在这个问题中，我们创建的dist矩阵完全可以代替这三个东西，首先把dist矩阵初始化为-1，当dist矩阵的某一位置等于-1，说明原矩阵mat的对应位置没有标记过，当dist的某一位置不为-1，此时该位置记录的就是最近距离，并且原矩阵mat的对应位置标记过。

对于step和sz变量的作用，dist也可以代替。因为我们是从坐标[a, b] – > [x,y]进行搜索的，而dist[a,b]记录的等同于就是对应的层数。

代码实现：

class Solution 
{
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
public:
    vector<vector<int>> updateMatrix(vector<vector<int>>& mat) 
    {
        int m = mat.size(), n = mat[0].size();

        // dist[i][j] == -1：mat[i][j]位置没有标记过
        // dist[i][j] ！= -1：最短路
        vector<vector<int>> dist(m, vector<int>(n, -1));

        queue<pair<int, int>> q;
        // 把0源点入队列
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
                if(mat[i][j] == 0)
                {
                    q.push({i, j});
                    dist[i][j] = 0;
                }

        while(q.size())
        {
            auto[a, b] = q.front();
            q.pop();
            for(int k = 0; k < 4; k++)
            {
                int x = a + dx[k], y = b + dy[k];
                if(x >= 0 && x < m && y >= 0 && y < n && dist[x][y] == -1)
                {
                    q.push({x, y});
                    dist[x][y] = dist[a][b] + 1;
                }
            }
        }
        return dist;
    }
};

当然，也可以使用"土方法"解决，这里也给出代码：

class Solution
{
    int m, n;

    int dx[4] = { 0,0,1,-1 };
    int dy[4] = { 1,-1,0,0 };
public:
    vector<vector<int>> updateMatrix(vector<vector<int>>& mat)
    {
        m = mat.size(), n = mat[0].size();
        vector<vector<int>> dist(m, vector<int>(n)); // 距离矩阵
        vector<vector<bool>> vis(m, vector<bool>(n)); // 标记矩阵

        queue<pair<int, int>> q;
        // 把所有的0入队列
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (mat[i][j] == 0)
                {
                    q.push({ i, j });
                    vis[i][j] = true;
                }
            }
        }

        int step = 0;
        while (q.size())
        {
            step++;
            int sz = q.size();
            while (sz--)
            {
                auto [a, b] = q.front();
                q.pop();
                for (int k = 0; k < 4; k++)
                {
                    int x = a + dx[k], y = b + dy[k];
                    if (x >= 0 && x < m && y >= 0 && y < n && !vis[x][y])
                    {
                        dist[x][y] = step;
                        q.push({ x, y });
                        vis[x][y] = true;
                    }
                }
            }
        }
        return dist;
    }
};

1020.飞地的数量

在这里插入图片描述
在这里插入图片描述

算法原理：

这道题目可以抽象成多源bfs问题。不直接统计有多少被包围的陆地，正难则反，我们从边界上的陆地(1)做突破口。把所有边界上的1都入队列，再使用多源bfs进行搜索标记，最后再遍历一遍原数组，统计出没有标记的陆地数量即可。
在这里插入图片描述

细节/技巧问题：

参考前文

代码实现：

class Solution 
{
    bool vis[501][501];

    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
public:
    int numEnclaves(vector<vector<int>>& grid) 
    {
        queue<pair<int, int>> q;
        // 把所有边界上的1入队列
        int m = grid.size(), n = grid[0].size();
        for(int i = 0; i < m; i++)
        {
            if(grid[i][0] == 1) q.push({i, 0}), vis[i][0] = true;
            if(grid[i][n-1] == 1) q.push({i, n-1}),vis[i][n-1] = true;
        }
        for(int j = 0; j < n; j++)
        {
            if(grid[0][j] == 1) q.push({0, j}), vis[0][j] = true;
            if(grid[m-1][j] == 1) q.push({m-1, j}), vis[m-1][j] = true;
        }

        // 用多源bfs进行搜索标记
        while(q.size())
        {
            auto[a,b] = q.front();
            q.pop();
            for(int k = 0; k < 4; k++)
            {
                int x = a+dx[k], y = b+dy[k];
                if(x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1 && !vis[x][y])
                {
                    q.push({x, y});
                    vis[x][y] = 2;
                }
            }
        }

        // 最后遍历原矩阵，根据标记数组，统计陆地数量
        int ret = 0;
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
                if(grid[i][j] == 1 && !vis[i][j])
                    ret++;

        return ret;
    }
};

1765.地图中的最高点

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

算法原理：

这道题完完全全就是第一题的变式题。本题只能根据水域高度推陆地高度，所以可以使用多源bfs把所有水域位置当成"超级源点"入队列，再一层一层向外扩展。代码的实现也几乎一模一样。

细节/技巧问题：

参考第一题

代码实现：

class Solution 
{
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
public:
    vector<vector<int>> highestPeak(vector<vector<int>>& isWater) 
    {
        int m = isWater.size(), n = isWater[0].size();
        vector<vector<bool>> vis(m, vector<bool>(n)); // 标记矩阵
        vector<vector<int>> hight(m, vector<int>(n)); // 高度矩阵

        queue<pair<int, int>> q;

        // 把所有水域入队列，搞定置为0
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
                if(isWater[i][j] == 1)
                {
                    q.push({i, j});
                    vis[i][j] = true;
                    hight[i][j] = 0; // 水域的高度为0
                }

        // 使用多源bfs进行标记统计
        while(q.size())
        {
            auto[a, b] = q.front();
            q.pop();
            for(int k = 0; k < 4 ; k++)
            {
                int x = a+dx[k], y = b+dy[k];
                if(x >= 0 && x < m && y >= 0 && y < n && !vis[x][y])
                {
                    hight[x][y] = hight[a][b] + 1;
                    q.push({x, y});
                    vis[x][y] = true;
                }
            }
        }
          
        return hight;
    }
};

1162.地图分析

在这里插入图片描述

在这里插入图片描述

算法原理：

这道题也是第一题的变式题。我们把所有的陆地看成起点入队列，再使用多源bfs向外一层一层扩展。
在这里插入图片描述

细节/技巧问题：

参考第一题

代码实现：

class Solution 
{
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
public:
    int maxDistance(vector<vector<int>>& grid) 
    {
        int m = grid.size(), n = grid[0].size();
        vector<vector<int>> dist(m, vector<int>(n, -1));

        queue<pair<int, int>> q;

        for(int i = 0; i < m; i++)
            for(int j= 0; j < n; j++)
                if(grid[i][j] == 1)
                {
                    // 所以陆地入队列，距离是0
                    q.push({i, j});
                    dist[i][j] = 0;
                }

        int ret = -1;
        while(q.size())
        {
            auto[a, b] = q.front();
            q.pop();
            for(int k = 0; k < 4; k++)
            {
                int x = a+dx[k], y = b+dy[k];
                if(x >= 0 && x < m && y >= 0 && y < n && dist[x][y] == -1)
                {
                    q.push({x, y});
                    dist[x][y] = dist[a][b] + 1;
                    ret = max(ret, dist[x][y]); // 更新出最大结果
                }
            }
        }

        return ret;

        // 下面是另一种更新出最大值的方式
        //int ret = 0;
        //int sum = 0;
        //for(int i = 0; i < m; i++)
        //    for(int j = 0; j < n; j++)
        //    {
        //        sum += dist[i][j];
        //        if(dist[i][j] >= ret)
        //            ret = dist[i][j];
        //    }
                
        //return (sum == 0 || sum == -m*n) ? -1 : ret;
    }
};

3. 算法总结

其实本篇文章的多源最短路和上一篇文章的单源最短路的思想基本上是一模一样的。无非一个是单起点一个是多起点，单起点就把那一个起点入队列就好了，而多起点就看成一个"超级源点"同时入队列就好了。如何把多个起点看成一个"超级源点"是关键，这就要根据题目具体分析了。

24k纯甄
关注
专栏目录
【基础算法总结】多源 BFS_多源最短路问题
fight_p的博客
08-19 1341
多源 BFS_多源最短路问题
BFS解决多源最短路相关leetcode算法题
m0_55283616的博客
12-25 577
【代码】BFS解决多源最短路相关leetcode算法题。
多源 BFS 详解
2301_80035594的博客
06-02 1523
在学习完单源最短路问题后，有些情况下使用单源最短路问题的解题方法会超时，这时就需要多源最短路了，今天就让我们来深入学习一下。
算法学习-广度优先遍历（单源BFS、多源BFS、双向BFS）
蒋大钊的博客
08-25 1179
广度优先遍历和深度优先遍历是图论中两大重要的算法，但是他们并不是只用于图，在树以及其他题目中都有重要的应用，因此我觉得值得笔者好好进行总结。
BFS算法求无权图最短路径问题
m0_68805093的博客
08-04 674
前一篇文章我们详细讲了BFS的原理及实现，在使用BFS遍历图的过程中，我们可以对每个顶点进行标记，标记当前顶点距离源头顶点的距离。这个距离我们用int d[i]来存储，由于BFS的性质，d[i]中存放的就是源头顶点v到顶点i的最短路径。
广度优先搜索BFS进阶(一)：多源BFS、优先队列BFS、双端队列BFS
yuhaomogui的博客
01-08 1626
普通队列BFS：适用于无权图；双端队列BFS：适用于边权为0或1且到每个顶点的边权都相等的带权图；优先队列BFS：适用于边权不为负且到每个顶点的边权都相等的带权图；如果图上到每个顶点的边权不等，则需使用最短路算法。
leetcode每日一题1765. 地图中的最高点 简单的多源BFS最短路问题 模板题
Alascanfu的博客
01-29 2387
本篇内容：leetcode每日一题1765. 地图中的最高点 简单的多源BFS最短路问题 模板题 文章专栏：leetcode每日一题《打卡日常》 最近更新：2022年1月28日 leetcode每日一题1996. 游戏中弱角色的数量 排序+遍历 实则是对lambda表达式的复习同时也是对贪心的复习 人简介：一只二本院校在读的大三程序猿，本着注重基础，打卡算法，分享技术作为个人的经验总结性的博文博主，虽然可能有时会犯懒，但是还是会坚持下去的，如果你很喜欢博文的话，建
C++知识点总结(53)：最短路算法
joe_g12345的博客
07-25 1420
号岛屿，就能找到传说中的大宝藏 OnePeaceⅡ，航海王看完之后想要挑战一下，别看现在的加勒比海是一片安静，由于天气和暗流的影响使得加勒比海蕴含着许多的危险，好在 Lucian 与小伙伴有着丰富的航海经验，曾多次在加勒比海航行，对于加勒比海任意两个岛屿之间的航线危险概率了如指掌，为了航行的安全航海王 Lucian 需要提前计算寻宝航线上危险概率之和，那么在找到大宝藏 OnePeaceⅡ 的前提下，最小的危险概率是多少呢？其中避开了 1 号和 2 号岛屿之间的航线，因为它的危险概率太大了。
最短路问题的五种算法
热门推荐
GD_ONE的博客
02-08 1万+
本文主要介绍关于图的最短路的五种常用算法和其应用。朴素Dijkstra堆优化DijkstraSPFAFloyd。这几种算法有各自的优势和劣势，适用于不同的场景。另：本篇文章篇幅较长，但难度不大， 建议学习算法的同时，自己手动画图，并模拟算法流程，将会一目了然，所见即所得！一定要画图。一定要刷题。写题的时候一定要注意是不是无向图， 无向图的话建边时要建一来一去两条,如果用邻接表存，数组一定要开足够大，至少是边数的两倍。对于邻接矩阵，要判断重边。邻接表则不需要判断重边。
最短路算法详解：BFS、Floyd、Dijkstra与SPFA
"该资源为PPT材料，主要讲解了图论中的最短路径算法，包括拓扑排序、最小生成树以及三种最短路径算法：BFS、Floyd和Dijkstra，同时也提到了SPFA（Shortest Path Faster Algorithm）算法和Bellman-Ford算法。这些算法...
BFS 的使用场景总结：层序遍历、最短路径问题
Rico_Rico_的博客
11-28 787
今天刷LeetCode102二叉树的层次遍历时发现一个很好的题解，拿过来记录，感谢作者@nettee 题目是这样子的： 给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。 --------------------------------------------- 示例： 二叉树：[3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 ---------------------------.
150道基础算法分类总结（2022）
小朱小朱绝不认输的博客
03-02 3157
在刷了一部分leetcode算法题之后，想要回头系统复习一下，发现刷的比较乱，特此整理一下，方便后续二刷，主要是对各种类型算法的一个分类，以及比较典型的题目的整理。 学习说明 题目来源lettcode 参考代码是用Java写的 供自己方便学习 算法分类 1. 二叉树 树也是一种非常重要的数据结构，因为很多容器的底层都设计到树，所以树也成了面试常问的重点了。特别是二叉树及二叉搜索树的算法。 二叉树的考点 题目来源 扩展 题解参考 二叉树的遍历（递归和迭代实现） 102. 二叉树的层序遍历
图论基础与算法解析
Floyd算法用于解决多源最短路问题，通过枚举中间点逐步更新最短路径。Dijkstra算法则是解决单源最短路问题的常用算法，它通过维护一个黑白顶点集合，每次选取距离源点最近的白顶点并更新其邻居的最短距离。
21_双端 diff 算法
qq_53109172的博客
11-01 543
简单 diff 算法的问题在于，它的移动操作并不是最优的，我们还是使用上一节的例子来看，如图：在这个例子中，我们使用简单 diff 算法来更新需要进行两次 DOM 移动，将 p-1 移动到 p-3 后面，将 p-2移动到 p-1 后面。但是其实只需要一次移动 DOM 即可，就是将 p-3 移动到 p-1 的前面即可。这一点想要实现，是简单 diff 算法无法做到的，而使用双端 diff 算法就可以。顾名思义，双端 diff 算法是一种同事对新旧两组子节点的两个端点进行比较的算法，因此我们需要四个索引值，分别
深⼊理解指针2
最新发布
ElePower9527的博客
11-01 424
指针访问数组内容时，有如下代码这⾥我们使⽤ &arr[0] 的⽅式拿到了数组第⼀个元素的地址，但是其实数组名本来就是地址，⽽且 是数组⾸元素的地址，我们来做个测试。输出结果我们发现数组名和数组⾸元素的地址打印出的结果⼀模⼀样，数组名就是数组⾸元素(第⼀个元素)的地址。注意有两个例外• sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩， 单位是字节。
【支持在线评测】二叉树计算
春秋招笔试突围
10-28 96
给定一个二叉树，请生成一个新的二叉树，使得新树中的每个节点的值等于原始树中该节点的左子树和右子树所有节点值的和。左子树表示该节点左侧叶子节点为根节点的一颗新树；右子树表示该节点右侧叶子节点为根节点的一颗新树。首先，需要根据给定的中序遍历和前序遍历序列重建原始二叉树。这是因为只有重建出原始树的结构，才能正确计算每个节点的子树和。在重建树的过程中，同时计算每个节点的子树和。输出一行整数，表示生成的新二叉树（求和树）的中序遍历序列，以空格分隔。最后，对重建并计算好子树和的树进行中序遍历，输出结果。
【算法】奇数在偶数后、反转字符串中的单词
2401_84568462的博客
10-29 298
输入一个整数数组，实现一个接口来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分。
力扣题目解析--正则表达式匹配
wxtg1921的博客
11-01 618
动态规划：使用动态规划方法来处理正则表达式的匹配问题，确保每个字符和模式的组合都被正确处理。索引检查：确保在访问字符串索引时，索引在有效范围内，避免越界错误。特殊情况处理：特别处理和的匹配规则，确保可以匹配零个或多个前面的字符，可以匹配任意字符。
实系数多项式的运算算法
分享代码和经验
11-01 902
这段代码通过定义一个Polynomial类来表示多项式，并实现了多项式的基本操作，如求值、相乘和相除。用户可以通过输入多项式的系数来创建多项式对象，并进行各种运算。代码清晰易读，适合用于学习多项式相关的数学概念和运算。
评论 89
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值