LeetCode矩阵题——用辐射来理解

542. 01 矩阵

给定一个由 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

注意:

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

分析：

想法一：广度优先搜索

1. 把每个源点0入队，然后每个0向1一圈一圈辐射扩散
2. 设置 int[ ] [ ]dist 来记录距离（即扩散的层次）并同时标志是否访问过

【注】要先把 matrix 数组中 1 的位置设置成 -1 （或无效的距离值）

广度优先搜索

找每个元素到最近的 0 的距离，即为，0到该元素的最短距离。可将0视作源点进行辐射。辐射过程如图所示。

1.红色为源点。

2.橙色为辐射第一圈。

3.黄色为辐射第二圈。（因此该其值为2）

由图可知，

1.将源点0（红色）入队，并将终点（即非0点，元素点）值改为-1,（-1为未访问）

2.将队列中结点弹出，并在四个方向辐射，向左向右向上向下（方向矢量为左（-1,0）右（1,0）上（0，-1）下（0，1）），得到辐射第一圈结点。并将辐射第一圈结点值改为1。

3.将辐射第一圈结点入队，然后依次弹出，并在四个方向辐射（忽略源点方向，即只往-1方向辐射），得到辐射第二圈结点。并将辐射第二圈结点值改为2。

…

重复执行上述步骤，直至队列为空

4.返回新的matrix矩阵

public class T542 {
    public int [][] updateMatrix(int[][] matrix){
        Queue<int[]> queue=new LinkedList<>();
        for (int i = 0; i < matrix.length; i++) {
            for(int j=0;j<matrix[0].length;j++){
                if(matrix[i][j]==0){
                    queue.offer(new int[]{i,j});//0元素入队
                }else {
                    matrix[i][j]=-1;//-1为未访问标记
                }
            }
        }
        //dx,dy表示坐标系中x,y向左、向右、向上、向下的分量
        int[] dx=new int[]{-1,1,0,0};
        int[] dy=new int[]{0,0,-1,1};
        while (!queue.isEmpty()){
            int[] point=queue.poll();//0元素出队
            int x=point[0],y=point[1];
            for (int i = 0; i < 4; i++) {
                //弹出的0元素向四个方向移动后的新坐标
                int newX=x+dx[i];
                int newY=y+dy[i];
                // 如果四邻域的点是 -1，表示这个点是未被访问过的 1
                // 所以这个点到 0 的距离就可以更新成 matrix[x][y] + 1。
                if (newX >= 0 && newX < matrix.length && 
                    newY >= 0 && newY < matrix[0].length//判断是否超出数组边界
                        && matrix[newX][newY] == -1) {//判断新坐标是否为终点-1
                    matrix[newX][newY] = matrix[x][y] + 1;//将终点值-1，改为源点值+1
                    queue.offer(new int[] {newX, newY});//将终点坐标加入队列，进行第二轮的辐射
                }
            }
        }
        return matrix;
    }

}

第二种

class Solution {
    public int[][] updateMatrix(int[][] matrix) {
        // 首先将 0 边上的 1 入队
        int[] dx = new int[] {-1, 1, 0, 0};
        int[] dy = new int[] {0, 0, -1, 1};
        Queue<int[]> queue = new LinkedList<>();
        int m = matrix.length, n = matrix[0].length;
        int[][] res = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (matrix[i][j] == 0) {
                    for (int k = 0; k < 4; k++) {
                        int x = i + dx[k];
                        int y = j + dy[k];
                        if (x >= 0 && x < m && y >= 0 && y < n 
                                && matrix[x][y] == 1 && res[x][y] == 0) {
                            // 这是在 0 边上的1。需要加上 res[x][y] == 0 的判断防止重复入队
                            res[x][y] = 1;
                            queue.offer(new int[] {x, y});
                        }
                    }
                }
            }
        }

        while (!queue.isEmpty()) {
            int[] point = queue.poll();
            int x = point[0], y = point[1];
            for (int i = 0; i < 4; i++) {
                int newX = x + dx[i];
                int newY = y + dy[i];
                if (newX >= 0 && newX < m && newY >= 0 && newY < n 
                        && matrix[newX][newY] == 1 && res[newX][newY] == 0) {
                    res[newX][newY] = res[x][y] + 1;
                    queue.offer(new int[] {newX, newY});
                }
            }
        }

        return res;
    }
}

动态规划

class Solution {
  public int[][] updateMatrix(int[][] matrix) {
    int m = matrix.length, n = matrix[0].length;
    int[][] dp = new int[m][n];
    for (int i = 0; i < m; i++) {
      for (int j = 0; j < n; j++) {
        dp[i][j] = matrix[i][j] == 0 ? 0 : 10000;
      }
    }

    // 从左上角开始
    for (int i = 0; i < m; i++) {
      for (int j = 0; j < n; j++) {
        if (i - 1 >= 0) {
          dp[i][j] = Math.min(dp[i][j], dp[i - 1][j] + 1);
        }
        if (j - 1 >= 0) {
          dp[i][j] = Math.min(dp[i][j], dp[i][j - 1] + 1);
        }
      }
    }
    // 从右下角开始
    for (int i = m - 1; i >= 0; i--) {
      for (int j = n - 1; j >= 0; j--) {
        if (i + 1 < m) {
          dp[i][j] = Math.min(dp[i][j], dp[i + 1][j] + 1);
        }
        if (j + 1 < n) {
          dp[i][j] = Math.min(dp[i][j], dp[i][j + 1] + 1);
        }
      }
    }
    return dp;
  }
}