每日OJ题_多源BFS①_力扣542. 01 矩阵（多源BFS解决最短路原理）

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

力扣542. 01 矩阵

解析代码

多源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;
    }
};