LeetCode 1162 地图分析

你现在手里有一份大小为 N x N 的『地图』（网格） grid，上面的每个『区域』（单元格）都用 0 和 1 标记好了。其中 0 代表海洋，1 代表陆地，你知道距离陆地区域最远的海洋区域是是哪一个吗？请返回该海洋区域到离它最近的陆地区域的距离。
我们这里说的距离是『曼哈顿距离』（ Manhattan Distance）：(x0, y0) 和 (x1, y1) 这两个区域之间的距离是 |x0 - x1| + |y0 - y1| 。
如果我们的地图上只有陆地或者海洋，请返回 -1。

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

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

来源：力扣（LeetCode）

这道题跟LeetCode994腐烂的橘子相似，个人感觉甚至比其更简单。
首先，遍历搜索所有的陆地（这里注意如果陆地数量为0或N*N都返回-1），将所有陆地加入队列；
每一轮都将上一轮加入的陆地弹出，弹出的陆地再去扩展找到相邻的新的海洋，把它们变成陆地并加入队列；
最终，所有的海洋都变为陆地。此时得到的轮数减1就是最远距离了。

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

    public int maxDistance(int[][] grid) {
        int N = grid.length;
        int max = 0;

        LinkedList<Integer> linkedList = new LinkedList<>(); //队列

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (grid[i][j] == 1) {
                    linkedList.add(i * N + j);
                }
            }
        }

        int sz = linkedList.size(); //每轮bfs需要出队的陆地数量
        if (sz == 0 || sz == N * N) {
            return -1;
        }

        int round = 0; //bfs的轮数
        while (!linkedList.isEmpty()) {
            round++;
            sz = linkedList.size();
            while (sz > 0) {
                int node = linkedList.removeFirst();
                int nodeX = node / N;
                int nodeY = node % N;
                for(int k = 0; k < 4; k++) {
                    int newX = nodeX + dx[k];
                    int newY = nodeY + dy[k];
                    if(newX >= 0 && newX < N && newY >= 0 && newY < N && grid[newX][newY] == 0) {
                        grid[newX][newY] = 1; //该海洋置为陆地
                        linkedList.add(newX * N + newY);
                    }
                }
                sz--;
            }
        }

        return --round;
    }
}