找出矩阵中每个元素到0的最短距离

给定一个由 0 和 1 组成的矩阵，找出每个元素到最近的 0 的距离。

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

示例 1：

输入：
[[0,0,0],
[0,1,0],
[0,0,0]]

输出：
[[0,0,0],
[0,1,0],
[0,0,0]]
示例 2：

输入：
[[0,0,0],
[0,1,0],
[1,1,1]]

输出：
[[0,0,0],
[0,1,0],
[1,2,1]]

提示：

1. 给定矩阵的元素个数不超过 10000。
2. 给定矩阵中至少有一个元素是 0。
3. 矩阵中的元素只在四个方向上相邻: 上、下、左、右。

这里我们都会想到暴力枚举的方法，对矩阵中的每一个元素进行查找，找到此元素到0的最短距离。但时间复杂度为O((r*c)^2)。我们考虑使用另一种方法。通过广度优先搜索实现。首先说明算法思路：

我们可以从 00 的位置开始进行 广度优先搜索。广度优先搜索可以找到从起点到其余所有点的 最短距离，因此如果我们从 00 开始搜索，每次搜索到一个 11，就可以得到 00 到这个 11 的最短距离，也就离这个 11 最近的 00 的距离了（因为矩阵中只有一个 00）。

举个例子，如果我们的矩阵为：

其中只有一个 0，剩余的 1 我们用短横线表示。如果我们从 00 开始进行广度优先搜索，那么结果依次为：

也就是说，在广度优先搜索的每一步中，如果我们从矩阵中的位置 x 搜索到了位置 y，并且 y 还没有被搜索过，那么位置 y 离 0 的距离就等于位置 x 离 0的距离加上1。

对于实际的问题，矩阵中有很多的0，我选择用多源点广度优先的方法。设置一个超级源点S指向所有的0，如图：
那么我们算法的第一步，便是从超级源点出发，同时到达所有的0，第二步，扩展0的上下左右，把非0的位置设为1（此时距离0点的位置一定为1），如何达到同时的效果呢？在搜索的时候使用队列，第一次把搜索到的距离0为1的点加入队列。再出队列以此为基点进行搜索，把找到的非0点的距离赋值为此基点的距离+1。

我们需要用到两个辅助矩阵
一个seen[][]用来存储此元素是否被找到过
另一个为dist[][]存储该点到0的距离（若该点是0，距离也为0）

看一下代码：

class Solution {
    static int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};	//分别代表上下左右方向

    public int[][] updateMatrix(int[][] matrix) {
        int m = matrix.length, n = matrix[0].length;
        int[][] dist = new int[m][n];
        boolean[][] seen = new boolean[m][n];
        Queue<int[]> queue = new LinkedList<int[]>();
        // 将所有的 0 添加进初始队列中
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (matrix[i][j] == 0) {
                    queue.offer(new int[]{i, j});
                    seen[i][j] = true;
                }
            }
        }

        // 广度优先搜索
        while (!queue.isEmpty()) {
            int[] cell = queue.poll();
            int i = cell[0], j = cell[1];		//用来取出当前节点的坐标
            for (int d = 0; d < 4; ++d) {		//四个方向均搜索一遍
                int ni = i + dirs[d][0];
                int nj = j + dirs[d][1];
                if (ni >= 0 && ni < m && nj >= 0 && nj < n && !seen[ni][nj]) {
                    dist[ni][nj] = dist[i][j] + 1;
                    queue.offer(new int[]{ni, nj});		//把搜索到的此节点在加入队列
                    seen[ni][nj] = true;				//标志此节点为ture
                }
            }
        }

        return dist;
    }
}

广度优先的算法并不困难，思想也比较好理解，再回顾一下过程
首先找到所有0节点，加入队列

进行广度优先第一轮，找到周围所有的非零节点，将其设为1

同时找到的1节点入队列，以此为基，找到的新节点在此基础上距离加1

直到搜索完成。