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）
链接：https://leetcode-cn.com/problems/as-far-from-land-as-possible
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

代码1：参考Lately

class Solution {
public:
    int maxDistance(vector<vector<int>>& grid) {
        int landCount=0;
        int lastSpace=0;
        int turnCount=0;
        int N=grid.size();
        for(int i=0;i<N;i++){
            for(int j=0;j<N;j++){
                if(grid[i][j]==1)landCount++;
            }
        }
        if(landCount==N*N || landCount==0)return -1;
        lastSpace=N*N-landCount;
        while(lastSpace!=0){
            turnCount++;
            for(int i=0;i<N;i++){
                for(int j=0;j<N;j++){
                    if(grid[i][j]==turnCount){
                        if(i>0 && grid[i-1][j]==0){
                            grid[i-1][j]=turnCount+1;
                            lastSpace--;
                        }
                        if(i<N-1 && grid[i+1][j]==0){
                            grid[i+1][j]=turnCount+1;
                            lastSpace--;
                        }
                        if(j>0 && grid[i][j-1]==0){
                            grid[i][j-1]=turnCount+1;
                            lastSpace--;
                        }
                        if(j<N-1 && grid[i][j+1]==0){
                            grid[i][j+1]=turnCount+1;
                            lastSpace--;
                        }
                    }
                }
            }
        }
        return turnCount;
    }
};

参考2：nettee

class Solution {
public:
    int maxDistance(vector<vector<int>>& grid) {
        int N=grid.size();
        queue<pair<int,int>>que;
        for(int i=0;i<N;i++){
            for(int j=0;j<N;j++){
                if(grid[i][j]==1)que.push({i,j});
            }
        }
        if(que.empty() || que.size()==N*N)return -1;
        int distance=-1;
        while(!que.empty()){
            distance++;
            int n=que.size();
            for(int i=0;i<n;i++){
                auto cell =que.front();
                que.pop();
                int r=cell.first;
                int c=cell.second;
                if(r-1>=0 && grid[r-1][c]==0){
                    grid[r-1][c]=2;
                    que.push({r-1,c});
                }
                if(r+1<N && grid[r+1][c]==0){
                    grid[r+1][c]=2;
                    que.push({r+1,c});
                }
                if(c-1>=0 && grid[r][c-1]==0){
                    grid[r][c-1]=2;
                    que.push({r,c-1});
                }
                if(c+1<N && grid[r][c+1]==0){
                    grid[r][c+1]=2;
                    que.push({r,c+1});
                }
            }
        }
        return distance;
    }
};