描述

给定一个由0和1组成的矩阵，求每个单元格最近的0的距离。
两个相邻细胞之间的距离是1。

给定矩阵的元素数不超过10,000。
在给定的矩阵中至少有一个0。
单元格在四个方向上相邻:上，下，左和右。

样例

例1:

输入:
[[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0]]
输出:
[[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0]]

例2:

输入:
[[0,1,0,1,1],[1,1,0,0,1],[0,0,0,1,0],[1,0,1,1,1],[1,0,0,0,1]]
输出:
[[0,1,0,1,2],[1,1,0,0,1],[0,0,0,1,0],[1,0,1,1,1],[1,0,0,0,1]]

本题主要考察广度优先搜索  

如需更快更简洁的算法请跳至思路2

思路1: 

思路1虽然也是广度优先搜索算法 但是是单源的广度优先搜索算法 即逐个继续遍历扩展其周围的元素

外层循环为每一层,内层循环为每一层的当前输入值

然后通过两个变量 path来记录路径的长度 队列来记录为未满足为0的位置索引 每次判断但凡队列的点相邻但凡没有一个符合条件就先让path+1  

然后记录所有不符合的点 直至循环出相邻有0的点 因为题目已经告知给定的矩阵至少有一个0

这就是每一个元素的遍历

最后将所有元素都这样执行一遍就可以得到每一个单元距离0的距离

即简要理解为针对每个 1 向外找最近 0

代码如下:

import java.util.*;

public class Solution {

    /**

     * @param matrix: a 0-1 matrix

     * @return: return a matrix

     */

    public int[][] updateMatrix(int[][] matrix) {

        int m = matrix.length;

        int n = matrix[0].length;

        int[][] pathMatrix = new int[m][n]; // 最终结果矩阵

        int path; // 当前单元格的路径

        Queue<int[]> integerQueue = new LinkedList<>(); // 存坐标的队列

        // 遍历每个单元格

        for (int i = 0; i < m; i++) {

            for (int j = 0; j < n; j++) {

                if (matrix[i][j] == 0) {

                    pathMatrix[i][j] = 0;

                } else {

                    // BFS 查找最近的 0

                    boolean[][] visited = new boolean[m][n];

                    integerQueue.clear();

                    integerQueue.offer(new int[]{i, j});

                    visited[i][j] = true;

                    path = 0;

                    boolean found = false;

                    while (!integerQueue.isEmpty() && !found) {

                        int size = integerQueue.size();

                        path++; // 每扩展一层，路径 +1

                        for (int q = 0; q < size; q++) {

                            int[] pos = integerQueue.poll();

                            int x = pos[0];

                            int y = pos[1];

                            int[][] dirs = {{-1,0},{1,0},{0,-1},{0,1}}; // 上下左右

                            for (int[] dir : dirs) {

                                int nx = x + dir[0];

                                int ny = y + dir[1];

                                if (nx >= 0 && nx < m && ny >= 0 && ny < n && !visited[nx][ny]) {

                                    if (matrix[nx][ny] == 0) {

                                        pathMatrix[i][j] = path;

                                        found = true;

                                        break;

                                    } else {

                                        integerQueue.offer(new int[]{nx, ny});

                                        visited[nx][ny] = true;

                                    }

                                }

                            }

                            if (found) break;

                        }

                    }

                }

            }

        }

        return pathMatrix;

    }

}

时间复杂度为:O(m × n)^2

思路2:多源广度优先算法

同时从多个起点出发进行 BFS，也就是说：
不是一个一个来，而是全部起点一起“向外一层层扩散”

即所有 0 一起扩散  访问一次就是最短路径 无冗余访问 即类似于同步水波扩散

需要注意的是 

m代表的是行数

n代表的是列数

代码如下:

public class Solution {

    public int[][] updateMatrix(int[][] matrix) {

        int m = matrix.length;

        int n = matrix[0].length;

        int[][] pathMatrix = new int[m][n];

        boolean[][] visited = new boolean[m][n];

        Queue<int[]> integerQueue = new LinkedList<>();

        //注意这里用LinkList 因为效率高 入队出队都是O(1) 而且LinkList实现了Deque,Deque又继承了队列,所以Queue可以直接用其实现类 LinkList.

        // 将所有为0的点入队，作为BFS的起点

        for (int y = 0; y < m; y++) {

            for (int x = 0; x < n; x++) {

                if (matrix[y][x] == 0) {

                    integerQueue.offer(new int[]{y, x});

                    visited[y][x] = true;

                }

            }

        }

        // 上下左右

        int[][] directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

        while (!integerQueue.isEmpty()) {

            int[] point = integerQueue.poll();

            int y = point[0], x = point[1];

            for (int[] dir : directions) {

                int newY = y + dir[0];

                int newX = x + dir[1];

                if (newY >= 0 && newY < m && newX >= 0 && newX < n && !visited[newY][newX]) {

                    pathMatrix[newY][newX] = pathMatrix[y][x] + 1;

                    visited[newY][newX] = true;

                    integerQueue.offer(new int[]{newY, newX});

                }

            }

        }

        return pathMatrix;

    }

}