力扣 1162. 地图分析

题目

你现在手里有一份大小为 N x N 的 网格 grid，上面的每个 单元格 都用 0 和 1 标记好了。其中 0 代表海洋，1 代表陆地，请你找出一个海洋单元格，这个海洋单元格到离它最近的陆地单元格的距离是最大的。

我们这里说的距离是「曼哈顿距离」（ Manhattan Distance）：(x0, y0) 和 (x1, y1) 这两个单元格之间的距离是 |x0 - x1| + |y0 - y1| 。

如果网格上只有陆地或者海洋，请返回 -1。

示例

输入：[[1,0,1],[0,0,0],[1,0,1]]
输出：2
解释：
海洋单元格 (1, 1) 和所有陆地单元格之间的距离都达到最大，最大距离为 2。

输入：[[1,0,0],[0,0,0],[0,0,0]]
输出：4
解释：
海洋单元格 (2, 2) 和所有陆地单元格之间的距离都达到最大，最大距离为 4。

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

方法1

多源点的BFS实现。
和 力扣 542. 01 矩阵 方法差不多。
542是求每一个的步数，而这道题是求遍历的最大步数。

Java实现1

class Solution {
    public int maxDistance(int[][] grid) {
        int row = grid.length, col = grid[0].length;
        Queue<int []> q = new LinkedList<>();
        int[] directions = {-1, 0, 1, 0, -1};
        
        int step = 0;

        //所有陆地入队
        for (int i = 0; i < row; i++){
            for (int j = 0; j < col; j++){
                if (grid[i][j] == 1) q.offer(new int[]{i, j});
            }
        }

        //没有陆地
        if (q.size() == 0) return -1;

        //没有海洋
        if (q.size() == row * col) return -1;

        while (!q.isEmpty()){
            int sz = q.size();

            for (int i = 0; i < sz; i++){
                int[] cur = q.poll();

                //上、右、下、左，4个方向遍历。
                for (int j = 0; j < directions.length - 1; j++){
                    int x = cur[0] + directions[j];
                    int y = cur[1] + directions[j + 1];

                    //超出矩阵范围或不是海洋(包括已遍历过、是陆地)则跳过
                    if (x < 0 || x >= row || y < 0 || y >= col || grid[x][y] != 0) continue;
                    //遍历过海洋的设置为2
                    grid[x][y] = 2;
                    q.offer(new int[] {x, y});
                }
            }
            step++;
        }
        //最后结束的时候，step多加了1，因此要减1
        return step - 1;
    }
}

Java实现2

// 方向
    static int[][] dirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    public int maxDistance(int[][] grid) {
        int m = grid.length, n = grid[0].length;
        // 初始队列
        Queue<int[]> queue = new LinkedList<>();
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 1) {
                    queue.offer(new int[]{i, j});
                } else {
                    grid[i][j] = -1;
                }
            }
        }
        // 如果全为陆地或嗨哟
        if (queue.size() == m * n || queue.size() == 0) return -1;
        // BFS
        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            int row = cur[0], cln = cur[1];
            for (int i = 0; i < 4; i++) {
                int newRow = row + dirs[i][0];
                int newCln = cln + dirs[i][1];
                if (newRow < 0 || newCln < 0 || newRow >= m || newCln >= n || grid[newRow][newCln] > 0) continue;
                grid[newRow][newCln] = grid[row][cln] + 1;
                // 周围节点入队
                queue.offer(new int[]{newRow, newCln});
            }
        }

        int maxDist = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                maxDist = Math.max(maxDist, grid[i][j]);
            }
        }

        return maxDist - 1;
    }