LeetCode 1162 地图分析

题目：

你现在手里有一份大小为 N x N 的『地图』（网格） grid，上面的每个『区域』（单元格）都用 0 和 1 标记好了。其中 0 代表海洋，1 代表陆地，你知道距离陆地区域最远的海洋区域是是哪一个吗？请返回该海洋区域到离它最近的陆地区域的距离。

我们这里说的距离是『曼哈顿距离』（ Manhattan Distance）：(x0, y0) 和 (x1, y1) 这两个区域之间的距离是 |x0 - x1| + |y0 - y1| 。

如果我们的地图上只有陆地或者海洋，请返回 -1。

换个思路理解题目：如标题所示，将陆地一轮又一轮地扩大，直到覆盖完全，计算扩大了多少轮，输出轮数即可。

需要找一个海洋区域，满足它到陆地的最小距离是所有海洋区域最大的。

方法一：BFS（借助队列）时间复杂度：O(n4)，空间复杂度：该算法使用了 visited 数组，渐进空间复杂度为 O(n^2)

class Solution {
    //方法一：BFS
public:
    struct Coordinate {
        int x,y,step;
    };
    vector<vector<int>>a;
    static constexpr int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0}; //方向数组
    static constexpr int Max_N=100+5;
    int n,m;

    bool visited[Max_N][Max_N];

    int findNearestLand(int x,int y){
        memset(visited,0,sizeof visited); //动态分配内存
        queue<Coordinate>q; //队列，用来实现BFS
        q.push({x,y,0});
        visited[x][y]=1;  //已被访问过
        while(!q.empty()){
            Coordinate tmp=q.front();q.pop();
            for(int i=0;i<4;i++){
                int tx=tmp.x+dx[i],ty=tmp.y+dy[i];
                if(!(tx>=0&& tx<=n-1&& ty>=0&&ty<=m-1)) continue; //跳过本次循环
                if(!visited[tx][ty]){
                    q.push({tx,ty,tmp.step+1});
                    visited[tx][ty]=1;
                    if(a[tx][ty]) return tmp.step+1;
                }
            }
        }
        return -1;
    }

    int maxDistance(vector<vector<int>>& grid) {
        this->n=grid.size();
        this->m=grid[0].size();
        a=grid;
        int res=-1;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(!a[i][j]) //海洋
                   res=max(res,findNearestLand(i,j));
            }
        }
        return res;
    }
};

方法二：多源点最短路径

陆地区域作为源点集，海洋区域作为目标点集。

多源点BFS。添加超级源点可以使多源BFS退化成单源BFS。

（图片来自leetcode）

现在我们从超级源点开始做单源BFS，发现原先的多个源点只不过是BFS的第二层而已。

渐进时间复杂度 O(n^2)，渐进空间复杂度为 O(n^2)

class Solution {
    //方法二：多源点BFS
public:
    static constexpr int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0}; //方向数组
    static constexpr int Max_N=100+5;
    static constexpr int INF=int(1E6);

    struct Coordinate {
        int x,y;
    };

    queue<Coordinate>q;
    int d[Max_N][Max_N]; //路径距离存储

    int maxDistance(vector<vector<int>>& grid) {
        int n=grid.size();
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++)
               d[i][j]=INF;//初始化
        }

        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]){  //先将所有陆地区域 加入 队列中
                    d[i][j]=0; 
                    q.push({i,j});
                }
            }
        }
        while(!q.empty()){
            auto f=q.front();q.pop();
            for(int i=0;i<4;i++){
                int tx=f.x+dx[i],ty=f.y+dy[i];
                if (!(tx >= 0 && tx <= n - 1 && ty >= 0 && ty <= n - 1)) continue;
                if(d[tx][ty]>d[f.x][f.y]+1){//发现海洋，只有海洋的d[x][y]=INF
                    d[tx][ty]=d[f.x][f.y]+1; //海洋到陆地的距离
                    q.push({tx,ty});
                }
                  
            }
        }
        int ans=-1;
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(!grid[i][j]) //海洋
                  ans=max(ans,d[i][j]);
            }
        }
        return (ans == INF) ? -1 : ans;
    }
};