Leetcode 地图分析

你现在手里有一份大小为 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。

 

提示：

1. 1 <= grid.length == grid[0].length <= 100
2. grid[i][j] 不是 0 就是 1

class Solution {
    public int maxDistance(int[][] grid) {
        Queue<int[]> que=new LinkedList<>();
        int i,j,k,res,mres,x,y,n,m;
        n=grid.length;m=grid[0].length;
        int[][] f={{-1,0},{0,-1},{1,0},{0,1}};
        res=0;
        mres=n+m+1;
        for(i=0;i<n;i++){
            for(j=0;j<m;j++){
                if(grid[i][j]==0){
                    int[][] find=new int[n][m];
                    find[i][j]=1;
                    que.add(new int[] {i,j});
                    while(que.size()!=0){
                        int[] node=new int[2];
                        node=que.poll();
                        x=node[0];y=node[1];
                        if(grid[x][y]==1){
                            mres=find[x][y]-1;
                            break;
                        }
                        for(k=0;k<4;k++){
                            int dx=x+f[k][0];int dy=y+f[k][1];
                            if(dx>=0&&dx<n&&dy>=0&&dy<m&&find[dx][dy]==0){
                                find[dx][dy]=find[x][y]+1;
                                que.add(new int[] {dx,dy});
                            }
                        }
                    }
                    while(que.size()!=0) que.poll();
                    //System.out.println(mres);
                    if(mres==n+m+1) return -1;
                    else if(mres>res) res=mres;
                }
            }
        }
        if(res==0) return -1;
        return res;
    }
}