【Leetcode】1162. As Far from Land as Possible

题目地址：

https://leetcode.com/problems/as-far-from-land-as-possible/

给定一个$0-1$矩阵$A$，给定其中的坐标$(x,y)$，与其曼哈顿距离最近的$1$和这个点的曼哈顿距离表示为$f(x,y)$，要求 max ⁡ { f ( x , y ) ∣ A [ x ] [ y ] = 0 } \max\{f(x,y)|A[x][y]=0\} max{f(x,y)∣A[x][y]=0}。若矩阵只含$0$或者只含$1$则返回$-1$。

思路是BFS。先将所有的$1$的坐标加入队列，然后一层一层地对每个$1$向四个方向扩展，每扩展一格就记录步数，并标记为扩展过，直到最后一个$0$被扩展到，此时扩展的步数即为所求。代码如下：

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class Solution {
    public int maxDistance(int[][] grid) {
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return -1;
        }
        
        // 将所有的1的坐标加入队列
        Queue<int[]> queue = new LinkedList<>();
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == 1) {
                    queue.offer(new int[]{i, j});
                }
            }
        }
        
        // 特判，如果只含0或者只含1，则返回-1
        if (queue.isEmpty() || queue.size() == grid.length * grid[0].length) {
            return -1;
        }
        
        int res = -1;
        // 每次循环，都将队列里的坐标全部取出，并且每取出一个，
        // 就将其四周的0的坐标加入队列，并将0改为1
        while (!queue.isEmpty()) {
            res++;
            // 由于要分层遍历，所以要事先记录队列的size
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                int[] cur = queue.poll();
                int x = cur[0], y = cur[1];
                for (int[] next : getNexts(x, y, grid)) {
                    queue.offer(next);
                    grid[next[0]][next[1]] = 1;
                }
            }
        }
        
        return res;
    }
    
    // 返回所有与(x, y)四个方向相邻的0的坐标
    private List<int[]> getNexts(int x, int y, int[][] grid) {
        List<int[]> nexts = new ArrayList<>();
        int[] d = {1, 0, -1, 0, 1};
        for (int i = 0; i < 4; i++) {
            int nextX = x + d[i], nextY = y + d[i + 1];
            if (inBound(nextX, nextY, grid) && grid[nextX][nextY] == 0) {
                nexts.add(new int[]{nextX, nextY});
            }
        }
        
        return nexts;
    }
    
    private boolean inBound(int x, int y, int[][] grid) {
        return 0 <= x && x < grid.length && 0 <= y && y < grid[0].length;
    }
}

时空复杂度$O(mn)$。