孤岛问题统计

希希困了

已于 2022-11-12 12:55:10 修改

阅读量138

点赞数

分类专栏： # Flood fill 文章标签：算法 leetcode 职场和发展

于 2022-11-11 15:08:17 首次发布

本文链接：https://blog.csdn.net/qq_73169752/article/details/127806474

版权

Flood fill 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

孤岛数量

题目传送门

给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1：

输入：grid = [
["1","1","1","1","0"],
["1","1","0","1","0"],
["1","1","0","0","0"],
["0","0","0","0","0"]
]
输出：1
示例 2：

输入：grid = [
["1","1","0","0","0"],
["1","1","0","0","0"],
["0","0","1","0","0"],
["0","0","0","1","1"]
]
输出：3

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 300
grid[i][j] 的值为 '0' 或 '1'

class Solution {  
public: typedef pair<int,int>PII;
        bool st[310][310];
        PII q[90100];
int numIslands(vector<vector<char>>& grid) {//这里是主函数
        int ans=0,n=grid.size(),m=grid[0].size();//算一下地图长宽  
       
       
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
                 if (grid[i][j]=='1'&&!st[i][j])
                    {
                        dfs(grid,i,j);
                        ans++;
                    }
        return ans;   
    }
 void dfs(vector<vector<char>>& grid,int qd1,int qd2)
        { int n=grid.size(),m=grid[0].size();//算一下地图长宽 
                int hh=0,tt=0;
                q[0]={qd1,qd2};
                st[qd1][qd2]=true;
                int dx[4]={0,-1,0,1},dy[4]={1,0,-1,0};
                while(hh<=tt)
                {
                        auto t=q[hh++];
                        for(int i=0;i<4;i++)
                        {
                            int a=t.first+dx[i],b=t.second+dy[i];
                            if(a>=n||a<0||b>=m||b<0)continue;//这个if一定要比下一个if先判，顺序不能反，否则就会出现数组越界情况。
                            if(grid[a][b]=='0'||st[a][b])continue;
                                q[++tt]={a,b};
                                st[a][b]=true;
                        }
                }
        }
  
};

封闭的岛屿

题目

二维矩阵 grid 由 0 （土地）和 1 （水）组成。岛是由最大的4个方向连通的 0 组成的群，封闭岛是一个完全由1包围（左、上、右、下）的岛。

请返回封闭岛屿的数目。

示例 1：

输入：grid = [[1,1,1,1,1,1,1,0],[1,0,0,0,0,1,1,0],[1,0,1,0,1,1,1,0],[1,0,0,0,0,1,0,1],[1,1,1,1,1,1,1,0]]
输出：2
解释：
灰色区域的岛屿是封闭岛屿，因为这座岛屿完全被水域包围（即被 1 区域包围）。
示例 2：

输入：grid = [[0,0,1,0,0],[0,1,0,1,0],[0,1,1,1,0]]
输出：1
示例 3：

输入：grid = [[1,1,1,1,1,1,1],
[1,0,0,0,0,0,1],
[1,0,1,1,1,0,1],
[1,0,1,0,1,0,1],
[1,0,1,1,1,0,1],
[1,0,0,0,0,0,1],
[1,1,1,1,1,1,1]]
输出：2

提示：

1 <= grid.length, grid[0].length <= 100
0 <= grid[i][j] <=1

class Solution {  
public: typedef pair<int,int>PII;
        bool st[310][310];
        PII q[90100];
        int ans=0;
int closedIsland(vector<vector<int>>& grid) {//这里是主函数
        int n=grid.size(),m=grid[0].size();//算一下地图长宽  
       
       
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
                 if (grid[i][j]==0&&!st[i][j])
                    {
                        dfs(grid,i,j);
                    }
        return ans;   
    }
 void dfs(vector<vector<int>>& grid,int qd1,int qd2)
        { int n=grid.size(),m=grid[0].size();//算一下地图长宽 
                int hh=0,tt=0;
                q[0]={qd1,qd2};
                st[qd1][qd2]=true;
                int dx[4]={0,-1,0,1},dy[4]={1,0,-1,0};
                int flag=0;//封闭岛屿就是不会遍历到出界的情况，所以立个旗，下面若走到了出界continue的情况则旗置1；
                while(hh<=tt)
                {
                        auto t=q[hh++];
                        for(int i=0;i<4;i++)
                        {
                            int a=t.first+dx[i],b=t.second+dy[i];
                            if(a>=n||a<0||b>=m||b<0){flag=1;continue;}//这个if一定要比下一个if先判，顺序不能反，否则就会出现数组越界情况。
                            if(grid[a][b]==1||st[a][b])continue;
                                q[++tt]={a,b};
                                st[a][b]=true;
                        }
                }
                if(flag==0)ans++;//说明遍历完这个岛的所有土地方块都没有涉及到出界，则为封闭岛屿。
        }
  
};

孤岛最大面积

题目

给你一个大小为 m x n 的二进制矩阵 grid 。

岛屿是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直的四个方向上相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。

岛屿的面积是岛上值为 1 的单元格的数目。

计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。

示例 1：

输入：grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]]
输出：6
解释：答案不应该是 11 ，因为岛屿只能包含水平或垂直这四个方向上的 1 。
示例 2：

输入：grid = [[0,0,0,0,0,0,0,0]]
输出：0

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 50
grid[i][j] 为 0 或 1

class Solution {
public:int ans =0;
    typedef pair<int,int>PII;
    PII q[2600];
    bool st[60][60];
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        int n=grid.size(),m=grid[0].size();
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
                if(!st[i][j]&&grid[i][j]==1)
                    {
                        ans=max(ans,dfs(grid,i,j));//每次找完一块岛，更新一下最大面积
                    }
        return ans;
    }
    int dfs(vector<vector<int>>&grid,int qd1,int qd2)
    {    int n=grid.size(),m=grid[0].size();
        int res=0;
        int hh=0,tt=0;
        q[0]={qd1,qd2};
        st[qd1][qd2]=true;
        while(hh<=tt)
        {   res++;//每一次出队代表一个小土地方块代表面积+1
            auto t=q[hh++];
            int dx[4]={0,-1,0,1},dy[4]={1,0,-1,0};
            for(int i=0;i<4;i++)
            {
                int a=t.first+dx[i],b=t.second+dy[i];     
                if(a<0||a>=n||b<0||b>=m)continue;//这个if一定要比下一个if先判，顺序不能反，否则就会出现数组越界情况。
                 if(grid[a][b]==0||st[a][b])continue;
                q[++tt]={a,b};
                st[a][b]=true;
            }
        }
        return res;
    }
};

统计子岛屿

题目

给你两个 m x n 的二进制矩阵 grid1 和 grid2 ，它们只包含 0 （表示水域）和 1 （表示陆地）。一个岛屿是由四个方向（水平或者竖直）上相邻的 1 组成的区域。任何矩阵以外的区域都视为水域。

如果 grid2 的一个岛屿，被 grid1 的一个岛屿完全包含，也就是说 grid2 中该岛屿的每一个格子都被 grid1 中同一个岛屿完全包含，那么我们称 grid2 中的这个岛屿为子岛屿。

请你返回 grid2 中子岛屿的数目。

示例 1：

输入：grid1 = [[1,1,1,0,0],[0,1,1,1,1],[0,0,0,0,0],[1,0,0,0,0],[1,1,0,1,1]], grid2 = [[1,1,1,0,0],[0,0,1,1,1],[0,1,0,0,0],[1,0,1,1,0],[0,1,0,1,0]]
输出：3
解释：如上图所示，左边为 grid1 ，右边为 grid2 。
grid2 中标红的 1 区域是子岛屿，总共有 3 个子岛屿。
示例 2：

输入：grid1 = [[1,0,1,0,1],[1,1,1,1,1],[0,0,0,0,0],[1,1,1,1,1],[1,0,1,0,1]], grid2 = [[0,0,0,0,0],[1,1,1,1,1],[0,1,0,1,0],[0,1,0,1,0],[1,0,0,0,1]]
输出：2
解释：如上图所示，左边为 grid1 ，右边为 grid2 。
grid2 中标红的 1 区域是子岛屿，总共有 2 个子岛屿。

提示：

m == grid1.length == grid2.length
n == grid1[i].length == grid2[i].length
1 <= m, n <= 500
grid1[i][j] 和 grid2[i][j] 都要么是 0 要么是 1 。

class Solution {
public: bool st1[550][550];
        bool st2[550][550];
        int ans=0,n=0,m=0;
        pair<int,int>q[250100];
    int countSubIslands(vector<vector<int>>& grid1, vector<vector<int>>& grid2) {
             n = grid1.size();
             m = grid1[0].size() ;
            for(int i=0;i<n;i++)//先走一遍1岛，把所有土方块的st1都改为true即可
                for(int j=0;j<m;j++)
                    if(grid1[i][j]==1)st1[i][j]=true;
                       
                    
            for(int i=0;i<n;i++)
                for(int j=0;j<m;j++)
                    if(!st2[i][j]&&grid2[i][j]==1)
                    {
                        ans+=dfs(grid2,i,j);
                    }
        return ans;
    }
    int dfs(vector<vector<int>>& grid2,int qd1,int qd2)
    {   
        int hh=0,tt=0;
        st2[qd1][qd2]=true;
        q[0]={qd1,qd2};
        bool flag=true;
        while(hh<=tt)
        {
            auto t=q[hh++];
            if(!st1[t.first][t.second])flag=false;//若当前土方块在st1中未被标true，说明1岛上这个地方并不是土地，也就是说明这当前dfs的一整座岛屿都不是子岛屿
            int dx[4]={0,1,-1,0},dy[4]={1,0,0,-1};
            for(int i=0;i<4;i++)
            {
                int a=t.first+dx[i],b=t.second+dy[i];
                if(a<0||a>=n||b<0||b>=m)continue;
                if(st2[a][b]||grid2[a][b]==0)continue;
                q[++tt]={a,b};
                st2[a][b]=true;
            }
        }
        if(flag)return 1;
       
        return 0;
    }
};