Offer必备算法28_多源BFS_四道力扣题详解（由易到难）

GR鲸鱼

已于 2024-05-27 17:21:52 修改

阅读量1.6k

点赞数 58

分类专栏： ⑧Offer必备算法（由易到难刷题） ⑤高阶数据结构与算法（C++描述）文章标签：宽度优先算法 c++ leetcode

于 2024-04-20 19:13:03 首次发布

本文链接：https://blog.csdn.net/GRrtx/article/details/136937489

版权

⑤高阶数据结构与算法（C++描述）同时被 2 个专栏收录

50 篇文章 1 订阅

订阅专栏

⑧Offer必备算法（由易到难刷题）

39 篇文章 0 订阅

订阅专栏

多源BFS解决最短路算法原理

什么是单源最短路 / 多源最短路？

之前的BFS解决最短路都是解决的单源最短路。

画图来说，单源最短路问题即为：

而对于多源最短路问题:

如何解决此类题？

自然是利用多源BFS解决，下面提出解法：

当我们将所有的源点作为一个源点来进行解题时，问题又变成了单源最短路问题，而为什么可以认为这种解法是正确的呢?

感性的理解：对于上图的ABC三点，显然A点到目标点的距离更远，当我们将其作为一个点时，A点就会被直接排除，此时该特殊源点实际上就是最近的源点的合并。

对于解法二，如何编写代码？

对于单源最短路问题的BFS解法为：

将起始点加入到队列中，再进行一层一层的扩展

自然，对于多源最短路的BFS解法为：

将所有的起始点加入到队列中，再进行一层一层的扩展

①力扣542. 01 矩阵

542. 01 矩阵

难度中等

给定一个由 0 和 1 组成的矩阵 mat ，请输出一个大小相同的矩阵，其中每一个格子是 mat 中对应位置元素到最近的 0 的距离。

两个相邻元素间的距离为 1 。

示例 1：

输入：mat = [[0,0,0],[0,1,0],[0,0,0]]
输出：[[0,0,0],[0,1,0],[0,0,0]]

示例 2：

输入：mat = [[0,0,0],[0,1,0],[1,1,1]]
输出：[[0,0,0],[0,1,0],[1,2,1]]

提示：

m == mat.length
n == mat[i].length
1 <= m, n <= 10^4
1 <= m * n <= 10^4
mat[i][j] is either 0 or 1.
mat 中至少有一个 0

class Solution {
public:
    vector<vector<int>> updateMatrix(vector<vector<int>>& mat) {

    }
};

解析代码

对于求的最终结果，有两种方式：

第一种方式：从每一个 1 开始，然后通过层序遍历找到离它最近的 0 。这一种方式，会以所有的 1 起点，来一次层序遍历，势必会遍历到很多重复的点。并且如果矩阵中只有一个 0 的话，每一次层序遍历都要遍历很多层，时间复杂度较高。
第二种方式：正难则反，从 0 开始层序遍历，并且记录遍历的层数。当第一次碰到 1 的时候，当前的层数就是这个 1 离 0 的最短距离。

第二种方式，在遍历的时候标记一下处理过的 1 ，能够做到只用历整个矩阵一次，就能得到最终结果。但是有一个问题， 0 是有很多个的，怎么才能保证遇到的 1 距离这一个 0 是最近的呢？可以先把所有的 0 都放在队列中，把它们当成一个整体，每次把当前队列里面的所有元素向外扩展一次。可以开一个dist数组就能完成类似前面BFS解决最短路所需的bool数组，step和size变量：初始化成-1的话就是没遍历的，遍历的step只需在前一个格子加1，层数也能确定。

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();
        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(mat[i][j] == 0)
                {
                    q.push({i, j});
                    dist[i][j] = 0;
                }
            }
        }
        while(!q.empty()) // ⼀层⼀层往外扩
        {
            auto [a, b] = q.front();
            q.pop();
            for(int i = 0; i < 4; ++i)
            {
                int x = a + dx[i], y = b + dy[i];
                if(x >= 0 && x < m && y >= 0 && y < n && dist[x][y] == -1)
                {
                    dist[x][y] = dist[a][b] + 1;
                    q.push({x, y});
                }
            }
        }
        return dist;
    }
};

也可以不开空间直接在原数组操作

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();
        queue<pair<int, int>> q;
        for(int i = 0; i < m; i++) // 把所有的源点加⼊到队列中
        {
             for(int j = 0; j < n; j++)
             {
                if(mat[i][j] == 0)
                    q.push({i, j});
                else
                    mat[i][j] = -1;

            }
        }
        while(!q.empty()) // ⼀层⼀层往外扩
        {
            auto [a, b] = q.front();
            q.pop();
            for(int i = 0; i < 4; ++i)
            {
                int x = a + dx[i], y = b + dy[i];
                if(x >= 0 && x < m && y >= 0 && y < n && mat[x][y] == -1)
                {
                    mat[x][y] = mat[a][b] + 1;
                    q.push({x, y});
                }
            }
        }
        return mat;
    }
};

②力扣1020. 飞地的数量

1020. 飞地的数量

难度中等

给你一个大小为 m x n 的二进制矩阵 grid ，其中 0 表示一个海洋单元格、1 表示一个陆地单元格。

一次移动是指从一个陆地单元格走到另一个相邻（上、下、左、右）的陆地单元格或跨过 grid 的边界。

返回网格中无法在任意次数的移动中离开网格边界的陆地单元格的数量。

示例 1：

输入：grid = [[0,0,0,0],[1,0,1,0],[0,1,1,0],[0,0,0,0]]
输出：3
解释：有三个 1 被 0 包围。一个 1 没有被包围，因为它在边界上。

示例 2：

输入：grid = [[0,1,1,0],[0,0,1,0],[0,0,1,0],[0,0,0,0]]
输出：0
解释：所有 1 都在边界上或可以到达边界。

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 500
grid[i][j] 的值为 0 或 1

class Solution {
public:
    int numEnclaves(vector<vector<int>>& grid) {
        
    }
};

解析代码

正难则反，从边上的 1 开始搜索，把与边上 1 相连的联通区域全部标记一下，然后再遍历一遍矩阵，看看哪些位置的 1 没有被标记即可标记的时候，可以用多源BFS解决。

class Solution {
    int dx[4] = {0, 0, -1, 1};
    int dy[4] = {1, -1, 0, 0};

public:
    int numEnclaves(vector<vector<int>>& grid) {
        int m = grid.size(), n = grid[0].size();
        queue<pair<int, int>> q;
        for(int j = 0; j < n; ++j) // 1. 处理边界的1
        {
            if(grid[0][j] == 1) // 第一行
            {
                grid[0][j] = -1;
                q.push({0, j});
            }
            if(grid[m - 1][j] == 1) // 最后一行
            {
                grid[m - 1][j] = -1;
                q.push({m - 1, j});
            }
        }
        for(int i = 0; i < m; ++i)
        {
            if(grid[i][0] == 1) // 第一列
            {
                grid[i][0] = -1;
                q.push({i, 0});
            }
            if(grid[i][n - 1] == 1) // 最后一列
            {
                grid[i][n - 1] = -1;
                q.push({i, n - 1});
            }
        }

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

        int ret = 0;
        for(int i = 0; i < m; ++i)
        {
            for(int j = 0; j < n; ++j)
            {
                if(grid[i][j] == 1)
                    ++ret;
            }
        }
        return ret;
    }
};

③力扣1765. 地图中的最高点

1765. 地图中的最高点

难度中等

给你一个大小为 m x n 的整数矩阵 isWater ，它代表了一个由陆地和水域单元格组成的地图。

如果 isWater[i][j] == 0 ，格子 (i, j) 是一个陆地格子。
如果 isWater[i][j] == 1 ，格子 (i, j) 是一个水域格子。

你需要按照如下规则给每个单元格安排高度：

每个格子的高度都必须是非负的。
如果一个格子是水域，那么它的高度必须为 0 。
任意相邻的格子高度差至多为 1 。当两个格子在正东、南、西、北方向上相互紧挨着，就称它们为相邻的格子。（也就是说它们有一条公共边）

找到一种安排高度的方案，使得矩阵中的最高高度值最大。

请你返回一个大小为 m x n 的整数矩阵 height ，其中 height[i][j] 是格子 (i, j) 的高度。如果有多种解法，请返回 任意一个 。

示例 1：

输入：isWater = [[0,1],[0,0]]
输出：[[1,0],[2,1]]
解释：上图展示了给各个格子安排的高度。
蓝色格子是水域格，绿色格子是陆地格。

示例 2：

输入：isWater = [[0,0,1],[1,0,0],[0,0,0]]
输出：[[1,1,0],[0,1,1],[1,2,2]]
解释：所有安排方案中，最高可行高度为 2 。
任意安排方案中，只要最高高度为 2 且符合上述规则的，都为可行方案。

提示：

m == isWater.length
n == isWater[i].length
1 <= m, n <= 1000
isWater[i][j] 要么是 0 ，要么是 1 。
至少有 1 个水域格子。

class Solution {
public:
    vector<vector<int>> highestPeak(vector<vector<int>>& isWater) {
        
    }
};

解析代码

力扣542. 01 矩阵的变型题，直接用多源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<int>> high(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(isWater[i][j] == 1) // 1为水域，高度为0
                {
                    q.push({i, j});
                    high[i][j] = 0;
                }
            }
        }
        while(!q.empty()) // ⼀层⼀层往外扩
        {
            auto [a, b] = q.front();
            q.pop();
            for(int i = 0; i < 4; ++i)
            {
                int x = a + dx[i], y = b + dy[i];
                if(x >= 0 && x < m && y >= 0 && y < n && high[x][y] == -1)
                {
                    high[x][y] = high[a][b] + 1;
                    q.push({x, y});
                }
            }
        }
        return high;
    }
};

④力扣1162. 地图分析

1162. 地图分析

难度中等

你现在手里有一份大小为 n x n 的网格 grid，上面的每个单元格都用 0 和 1 标记好了。其中 0 代表海洋，1 代表陆地。

请你找出一个海洋单元格，这个海洋单元格到离它最近的陆地单元格的距离是最大的，并返回该距离。如果网格上只有陆地或者海洋，请返回 -1。

我们这里说的距离是「曼哈顿距离」（ Manhattan Distance）：(x0, y0) 和 (x1, y1) 这两个单元格之间的距离是 |x0 - x1| + |y0 - y1| 。

示例 1：

输入：grid = [[1,0,1],[0,0,0],[1,0,1]]
输出：2
解释： 
海洋单元格 (1, 1) 和所有陆地单元格之间的距离都达到最大，最大距离为 2。

示例 2：

输入：grid = [[1,0,0],[0,0,0],[0,0,0]]
输出：4
解释： 
海洋单元格 (2, 2) 和所有陆地单元格之间的距离都达到最大，最大距离为 4。

提示：

n == grid.length
n == grid[i].length
1 <= n <= 100
grid[i][j] 不是 0 就是 1

class Solution {
public:
    int maxDistance(vector<vector<int>>& grid) {

    }
};

解析代码

力扣542. 01 矩阵的变型题，这里的曼哈顿距离就是最短距离，正难则反，用多源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++) // 处理边界的1
        {
            for(int j = 0; j < n; j++)
            {
                if(grid[i][j])
                {
                    dist[i][j] = 0;
                    q.push({i, j});
                }
            }
        }

        int ret = -1; // 全是海洋返回-1
        while(!q.empty())
        {
            auto[a, b] = q.front();
            q.pop();
            for(int i = 0; i < 4; ++i)
            {
                int x = a + dx[i], y = b + dy[i];
                if(x >= 0 && x < m && y >= 0 && y < n && dist[x][y] == -1)
                {
                    dist[x][y] = dist[a][b] + 1;
                    ret = max(ret, dist[x][y]);
                    q.push({x, y});
                }
            }
        }
        return ret;
    }
};

本篇完。

下篇动态规划类型的是其它背包问题（二维费用背包 + 似包非包 + 卡特兰数）的OJ。

下下篇是BFS解决拓扑排序类型的OJ。

GR鲸鱼

关注

58
点赞
踩
11

收藏

觉得还不错? 一键收藏
打赏
0
评论
Offer必备算法28_多源BFS_四道力扣题详解（由易到难）

Offer必备算法28_多源BFS_四道力扣题详解（①力扣542. 01 矩阵+②力扣1020. 飞地的数量+③力扣1765. 地图中的最高点+④力扣1162. 地图分析）
复制链接

扫一扫