力扣542.01 矩阵

算法核心：多源BFS

题目链接：https://leetcode.cn/problems/01-matrix/

题目:

给定一个由 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 <= 104
• 1 <= m * n <= 104
• mat[i][j] is either 0 or 1.

算法思路：

对于求的最终结果，我们有两种方式：
• 第一种方式：从每一个 1 开始，然后通过层序遍历找到离它最近的 0 。
这一种方式，我们会以所有的 1 起点，来一次层序遍历，势必会遍历到很多重复的点。并且如果
矩阵中只有一个 0 的话，每一次层序遍历都要遍历很多层，时间复杂度较高。
• 换一种方式：从 0 开始层序遍历，并且记录遍历的层数。当第一次碰到 1 的时候，当前的层数
就是这个 1 离 0 的最短距离。
这一种方式，我们在遍历的时候标记一下处理过的 1 ，能够做到只用遍历整个矩阵一次，就能得
到最终结果。
但是，这里有一个问题， 0 是有很多个的，我们怎么才能保证遇到的 1 距离这一个 0 是最近的
呢？
其实很简单，我们可以先把所有的 0 都放在队列中，把它们当成一个整体，每次把当前队列里面的所有元素向外扩展一次。

简单来说，正难则反，正着来的思路难以下手就反着来。

下面是力扣ac代码：

class Solution {
public:
    int dx[4] = { 0, 0, 1, -1 };
    int dy[4] = { 1, -1, 0, 0 };
    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;
        // 1. 把所有的源点加入到队列中
        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;
                }
        // 2. 一层一层的往外扩
        while (q.size())
        {
            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;
    }
};