LeetCode220726_51、01 矩阵

给定一个由 0 和 1 组成的矩阵 mat ，请输出一个大小相同的矩阵，其中每一个格子是 mat 中对应位置元素到最近的 0 的距离。

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

示例 1：

图1 01矩阵示例图

输入：mat = [[0,0,0],[0,1,0],[0,0,0]]
输出：[[0,0,0],[0,1,0],[0,0,0]]

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/01-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题解一、多源BFS遍历，将所有0加入队列，并对非0元素进行未访问标记，距离当访问至非0元素时，将元素的距离设置成搜索基准的元素距离0的距离+1。

class Solution{
    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});
                } else{
                    matrix[i][j] = -1;
                }
            }
        }
    while(!queue.isEmpty()){
            int[] pos = queue.poll();
            int x = pos[0];
            int y = pos[1];
            int[] dx = {1, 0, 0, -1};
            int[] dy = {0, -1, 1, 0};
            for(int m = 0; m < 4; m++){
                int nextx = x + dx[m];
                int nexty = y + dy[m];
                if(nextx >= 0 && nextx < matrix.length && nexty >= 0 && nexty < matrix[0].length && matrix[nextx][nexty] == -1){
                    matrix[nextx][nexty] = matrix[x][y] + 1;
                    queue.offer(new int[]{nextx, nexty});
                }
            }
        }
        return matrix;
    }
}

题解二、dp算法，左上，右下两角开始，找距离0值最近的，若为0，则是本身，不为0，则此方向内，最近的 + 1。

class Solution{
    public int[][] updateMatrix(int[][] matrix){
        int m = matrix.length;
        int 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-1){
                    dp[i][j] = Math.min(dp[i][j],dp[i + 1][j] + 1);
                }
                if(j + 1 <= n -1){
                    dp[i][j] = Math.min(dp[i][j],dp[i][j + 1] + 1);
                }
            }
        }
        return dp;
    }

}