矩阵元素最近距离（动态规划 或 BFS）

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

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

BFS广度优先搜索

class Solution {
    public int[][] updateMatrix(int[][] mat) {
        Queue <int[]> queue = new LinkedList<>();
        int m = mat.length;
        int n = mat[0].length;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(mat[i][j]==0){
                    //添加矩阵中的所有0入队
                    queue.add(new int[] {i,j});
                }
                else{
                    //把其他的改为-1
                    mat[i][j] = -1;
                }
            }
        }
        //代表了向上下左右移动
        int[] dx = new int[]{-1,1,0,0};
        int[] dy = new int[]{0,0,-1,1};
        while(!queue.isEmpty()){
            int[] res = queue.poll();
            //分别向四个方向移动
            for(int i=0;i<4;i++){
               int newx = res[0] + dx[i];
               int newy = res[1] + dy[i];
               if(newx>=0 && newy>=0 && newx<m && newy<n && mat[newx][newy]==-1) {
               	   //没有被访问过的节点，就加一
                   mat[newx][newy] = mat[res[0]][res[1]] + 1;
                   //再把这个节点添加到队列中去
                   queue.add(new int[]{newx,newy});
               }
            }
        }
        return mat;
    }
}

动态规划

class Solution {
    public int[][] updateMatrix(int[][] mat) {
        int m = mat.length;
        int n = mat[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] = mat[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;
    }
}