LeetCode——542.01 矩阵

大佬，牛！！！

• 题目：给你一个二维数组，里面只有0和1，然后要求返回一个二维数组，二维数组中记录着所有的1到0的最短距离。
• 我的思路：首先肯定是层序遍历，也就是bfs，然后就是怎么遍历的问题。去找1，然后从1位置开始找，让后另外一个容器记录我们遍历的层，然后最后得到深度以后，把这些走过的层也都填充起来，大致是这样的思想，但是实在是写不动了。
• 大佬的思路BFS：其实我们从0开始找会更好一点。队列中存储的是我们已经填充完的。这样我们遍历队列，让他的周围没有填充过的都等于他+1即可。然后这个周围的填充完了以后，接着把他也放在队列中。因为我们用到的是bfs，所以我们会按照层的顺序进行，也就是先处理的都是0周围的，都处理成1，然后处理1周围的，都处理成2，并且处理过程中，如果已经处理过，则就不处理了。
• 大佬的思路DP：其实就是我们一定会从4个方向来到这个点，分别是左上、左下、右上、右下，我们分别统计这时候的值，然后取最小的即可。

java代码——BFS

class Solution {
    int[][] dir = {{1, 0}, {-1, 0}, {0, -1}, {0, 1}};

    public int[][] updateMatrix(int[][] mat) {
        int m = mat.length;
        int n = mat[0].length;
        int[][] ans = new int[m][n];
        boolean[][] vis = new boolean[m][n];
        Queue<Point> queue = new LinkedList<>();// 队列中放的是我们已经知道的
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (mat[i][j] == 0) {
                    queue.add(new Point(i, j));
                    vis[i][j] = true;
                }
            }
        }
        while (!queue.isEmpty()) {
            Point remove = queue.remove();
            for (int i = 0; i < 4; i++) {
                int nx = remove.x + dir[i][0];
                int ny = remove.y + dir[i][1];
                if (nx >= 0 && nx < m && ny >= 0 && ny < n && !vis[nx][ny]) {// 找到0的上下左右，
                    ans[nx][ny] = ans[remove.x][remove.y] + 1;
                    queue.add(new Point(nx, ny));
                    vis[nx][ny] = true;
                }
            }
        }
        return ans;
    }

    class Point {
        int x, y;

        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}

java代码——DP

class Solution {
    public int[][] updateMatrix(int[][] mat) {
        int m = mat.length;
        int n = mat[0].length;
        int[][] ans = new int[m][n];


        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (mat[i][j] == 0) {
                    ans[i][j] = 0;
                } else {
                    ans[i][j] = Integer.MAX_VALUE / 2;// 这个地方需要/2，不然+1以后会越界的
                }
            }
        }
        // 只会从左边和上边下来
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (j - 1 >= 0) {// 左边
                    ans[i][j] = Math.min(ans[i][j], ans[i][j - 1] + 1);
                }
                if (i - 1 >= 0) {// 上边
                    ans[i][j] = Math.min(ans[i][j], ans[i - 1][j] + 1);
                }
            }
        }
        // 只会从左边和下边下来
        for (int i = m - 1; i >= 0; --i) {
            for (int j = 0; j < n; j++) {
                if (j - 1 >= 0) {// 左边
                    ans[i][j] = Math.min(ans[i][j], ans[i][j - 1] + 1);
                }
                if (i + 1 < m) {// 上边
                    ans[i][j] = Math.min(ans[i][j], ans[i + 1][j] + 1);
                }
            }
        }
        // 只会从右边和上边下来
        for (int i = 0; i < m; i++) {
            for (int j = n - 1; j >= 0; --j) {
                if (j + 1 < n) {// 左边
                    ans[i][j] = Math.min(ans[i][j], ans[i][j + 1] + 1);
                }
                if (i - 1 >= 0) {// 上边
                    ans[i][j] = Math.min(ans[i][j], ans[i - 1][j] + 1);
                }
            }
        }
        // 只会从右边和上边下来
        for (int i = m - 1; i >= 0; --i) {
            for (int j = n - 1; j >= 0; --j) {
                if (j + 1 < n) {// 左边
                    ans[i][j] = Math.min(ans[i][j], ans[i][j + 1] + 1);
                }
                if (i + 1 < m) {// 上边
                    ans[i][j] = Math.min(ans[i][j], ans[i + 1][j] + 1);
                }
            }
        }
        return ans;
    }
}

• 总结：BFS主要是反其道而行之了，大佬是先找的0，而我的思路是从1开始。DP的思路，我不是很熟练，这里也算是学习了。附一下大佬链接。