图论基础|695. 岛屿的最大面积、1020. 飞地的数量、130. 被围绕的区域

已于 2024-03-22 22:20:00 修改
阅读量1.2k 收藏 24
点赞数 19
分类专栏： 代码随想录算法训练营 文章标签： 图论
于 2024-03-21 19:17:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60513199/article/details/136908995
版权

695. 岛屿的最大面积

力扣题目链接(opens new window)

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

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

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

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

  • 输入：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 。

思路：广度优先和深度优先皆可，遍历的时候计数，然后取最大数量即可

class Solution {
public:
    //深度优先版本
    int count=0;
    int result =0;
    int dir[4][2]={0,1,1,0,-1,0,0,-1};
    void dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y){
        for(int i=0;i<4;i++){
            int nextx= x+dir[i][0];
            int nexty=y+dir[i][1];
            if(nextx<0||nextx>=grid.size()||nexty<0||nexty>=grid[0].size())continue;
            if(!visited[nextx][nexty] && grid[nextx][nexty] == 1){
                
                visited[nextx][nexty]=true;
                count++;
                dfs(grid,visited,nextx,nexty);

            }
        }
        
    }
    int maxAreaOfIsland(vector<vector<int>>& grid) {
       int n=grid.size(); int m=grid[0].size();
        vector<vector<bool>>visited=vector<vector<bool>>(n,vector<bool>(m,false));
        for(int i=0;i<n;i++){
            for(int j=0; j<m;j++){
                if(!visited[i][j]&&grid[i][j]==1){
                    count=1;//遇到陆地先计数
                    visited[i][j]=true;
                    dfs(grid,visited,i,j);
                    result=max(result,count);
                }
            }
        }
        return result;
    }
};
//广度优先版本
class Solution {
public:
 
    int count=0;
    int result =0;
    int dir[4][2]={0,1,1,0,-1,0,0,-1};
    void dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y){
        queue<int>que;
        que.push(x);
        que.push(y);
        visited[x][y]=true;
        count++;
        while(!que.empty()){
            int xx=que.front(); que.pop();
            int yy=que.front(); que.pop();
            for(int i=0;i<4;i++){
                int nextx=  xx+dir[i][0];
                int nexty=  yy+dir[i][1];

                if(nextx<0||nextx>=grid.size()||nexty<0||nexty>=grid[0].size())continue;
                if(!visited[nextx][nexty] && grid[nextx][nexty] == 1){
                
                    visited[nextx][nexty]=true;
                    count++;
                    que.push(nextx);
                    que.push(nexty);

                }
            }
        }
        
    }
    int maxAreaOfIsland(vector<vector<int>>& grid) {
       int n=grid.size(); int m=grid[0].size();
        vector<vector<bool>>visited=vector<vector<bool>>(n,vector<bool>(m,false));
        for(int i=0;i<n;i++){
            for(int j=0; j<m;j++){
                if(!visited[i][j]&&grid[i][j]==1){
                    count=0;
                    visited[i][j]=true;
                    dfs(grid,visited,i,j);
                    result=max(result,count);
                }
            }
        }
        return result;
    }
};

1020. 飞地的数量

力扣链接(opens new window)

给你一个大小为 m x n 的二进制矩阵 grid ，其中 0 表示一个海洋单元格、1 表示一个陆地单元格。

一次 移动 是指从一个陆地单元格走到另一个相邻（上、下、左、右）的陆地单元格或跨过 grid 的边界。

返回网格中 无法 在任意次数的移动中离开网格边界的陆地单元格的数量。

  • 输入：grid = [[0,0,0,0],[1,0,1,0],[0,1,1,0],[0,0,0,0]]
  • 输出：3
  • 解释：有三个 1 被 0 包围。一个 1 没有被包围，因为它在边界上。

  • 输入：grid = [[0,1,1,0],[0,0,1,0],[0,0,1,0],[0,0,0,0]]
  • 输出：0
  • 解释：所有 1 都在边界上或可以到达边界

思路：本题要求找到不靠边的陆地面积，那么我们只要从周边找到陆地然后 通过 dfs或者bfs 将周边靠陆地且相邻的陆地都变成海洋，然后再去重新遍历地图的时候，统计此时还剩下的陆地就可以了。

遍历周边：分别遍历最左列（grid[i][0]),最右列（grid[i][m-1]),最上行（grid[0][j]),最下行（grid[n-1][j]),同时进行搜索，在搜索过程中将其置0。

class Solution {
public:
    //深度优先搜索
    int dir[4][2]={1,0,0,1,-1,0,0,-1};//四个方向
    int count;
    void dfs(vector<vector<int>>& grid, int x, int y){
        grid[x][y]=0;
        count++;
        for(int i=0; i<4; i++){
            int nextx= x+dir[i][0];
            int nexty=y+dir[i][1];
            if(nextx<0||nextx>=grid.size()||nexty<0||nexty>=grid[0].size())continue;
            if(grid[nextx][nexty]==1){
                // count++;
                // grid[nextx][nexty]=0;
                dfs(grid, nextx, nexty);
            }
        }
        return;
    }
    int numEnclaves(vector<vector<int>>& grid) {
        // int count=0;
        int n=grid.size();//行数
        int m=grid[0].size();//列数
        //遍历周边
        for(int i=0;i<n;i++){
            if(grid[i][0])dfs(grid, i,0);//遍历最左列
            if(grid[i][m-1])dfs(grid,i, m-1);//遍历最右列
        }
        for(int j=0; j<m;j++){
            if(grid[0][j])dfs(grid, 0, j);//遍历最上行
            if(grid[n-1][j])dfs(grid,n-1, j);//遍历最底行
        }
        
        //遍历整个网格，并计数
        count= 0;
        for(int i=0; i<n; i++){
            for(int j=0; j<m;j++){
                if(grid[i][j]){
                    // count++;
                    dfs(grid,i, j);
                }
            }
        }
        return count;
        

    }
};
//广度优先搜索
class Solution {
public:
    int count =0;
    int dir[4][2]={0,1,1,0,0,-1,-1,0};
    void bfs(vector<vector<int>>& grid, int x, int y){
        queue<pair<int,int>>que;
        que.push({x,y});
        count++;
        grid[x][y]=0;
        while(!que.empty()){
            pair<int,int>cur=que.front();que.pop();
            for(int i=0;i<4;i++){
                int nextx=cur.first+dir[i][0];
                int nexty=cur.second+dir[i][1];
                if(nextx<0||nextx>=grid.size()||nexty<0||nexty>=grid[0].size())continue;
                if(grid[nextx][nexty]){
                    que.push({nextx,nexty});
                    count++;
                    grid[nextx][nexty]=0;
                }

            }
            
        }
        return;
    }
    int numEnclaves(vector<vector<int>>& grid) {
        int n=grid.size();//行数
        int m=grid[0].size();//列数
        //遍历周边并置0
        for(int i=0;i<n;i++){
            if(grid[i][0])bfs(grid,i,0);//遍历最左列
            if(grid[i][m-1])bfs(grid,i,m-1);//遍历最右列
        }
        for(int j=0;j<m;j++){
            if(grid[0][j]) bfs(grid,0,j);//遍历第一行
            if(grid[n-1][j]) bfs(grid,n-1,j);//遍历最后一行
        }
        //重新遍历整个网格并计算
        count=0;
        for(int i=0; i<n;i++) {
            for(int j=0;j<m;j++){
                if(grid[i][j]){
                    bfs(grid,i,j);
                }
            }
        }
        return count;
    }
};

130. 被围绕的区域

题目链接(opens new window)

给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' ，找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。

  • 输入：board = [["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]
  • 输出：[["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]]
  • 解释：被围绕的区间不会存在于边界上，换句话说，任何边界上的 'O' 都不会被填充为 'X'。 任何不在边界上，或不与边界上的 'O' 相连的 'O' 最终都会被填充为 'X'。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的

思路：和上一题类似，只是需要把’飞地‘改为”X"

先广度优先或深度优先遍历周边，把周边的X换为'A'，然后两个for循环遍历整个grid,遇到'A'换成’O',遇到'O'换成‘X'

//广度优先搜索
class Solution {
public:
    int dir[4][2]={0,1,1,0,0,-1,-1,0};
    void dfs(vector<vector<char>>& board, int x, int y){
        board[x][y]='A';
        for(int i=0;i<4;i++){
            int nextx=x+dir[i][0];
            int nexty=y+dir[i][1];
            if(nextx<0||nextx>=board.size()||nexty<0||nexty>=board[0].size())continue;
            if(board[nextx][nexty]=='O'){
                dfs(board,nextx,nexty);
            }
        }
        return;
    }
    void solve(vector<vector<char>>& board) {
        int n=board.size();//行数
        int m=board[0].size();//列数
        //遍历周边，把周边的'O'换成’A‘
        for(int i=0;i<n;i++){
            if(board[i][0]=='O')dfs(board,i,0);//遍历最左列
            if(board[i][m-1]=='O')dfs(board,i,m-1);//遍历最右列
        }

        for(int j=0;j<m;j++){
            if(board[0][j]=='O')dfs(board,0,j);//最上行
            if(board[n-1][j]=='O')dfs(board,n-1,j);//最下行
        }

        //遍历整个网格并替换
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(board[i][j]=='O')board[i][j]='X';
                if(board[i][j]=='A') board[i][j]='O';
                
            }
        }
        

    }
};
class Solution {
public:
    int dir[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};
    void bfs(vector<vector<char>>& board, int x, int y) {
        queue<pair<int, int>> que;
        que.push({x, y});
        board[x][y]='A';
        while (!que.empty()) {
            pair<int, int> cur = que.front();
            que.pop();
            for (int i = 0; i < 4; i++) {
                int nextx = cur.first + dir[i][0];
                int nexty = cur.second + dir[i][1];
                if (nextx < 0 || nextx >= board.size() || nexty < 0 ||
                    nexty >= board[0].size())
                    continue;
                if (board[nextx][nexty] == 'O') {
                    board[nextx][nexty] = 'A';
                    // cout<<"board[nextx][nexty]:"<<board[nextx][nexty]<<endl;
                    que.push({nextx, nexty});
                    
                }
            }
        }
    }
    void solve(vector<vector<char>>& board) {
        int n = board.size();
        int m = board[0].size();
        // 遍历周边
        for (int i = 0; i < n; i++) {
            if (board[i][0] == 'O')
                bfs(board, i, 0);
            if (board[i][m - 1] == 'O')
                bfs(board, i, m - 1);
        }
        for (int j = 0; j < m; j++) {
            if (board[0][j] == 'O')
                bfs(board, 0, j);
            if (board[n - 1][j] == 'O')
                bfs(board, n - 1, j);
        }

        // 遍历整个网格并替换
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // cout<<"before: "<<board[i][j]<<endl;
                if (board[i][j] == 'O')
                    board[i][j] = 'X';
                if (board[i][j] == 'A')
                    board[i][j] = 'O';
                
                
            }
        }
    }
};

 参考：代码随想录

子墨_bupt
关注
专栏目录
CodeTop092 岛屿的最大面积
Oblak_ZY的博客
04-07 104
给你一个大小为mxn的二进制矩阵grid 岛屿是由一些相邻的1(代表土地)构成的组合,这里的「相邻」要求两个1必须在水平或者竖直的四个方向上相邻.你可以假设grid的四个边缘都被0(代表水)包围着 岛屿的面积是岛上值为1的单元格的数目 计算并返回grid中最大的岛屿面积.如果没有岛屿,则返回面积为0 这题一如既往的DFS就能完成,但是要个之前有一个岛屿个数的问题区分开了就行了,一个是合并岛屿,一个是计算岛屿的最大面积 public int maxAreaOfIsland(int[][] grid) { .
图论算法软件Graph.exe
02-03
Graph.exe是一个图论算法软件，用于执行各种图论算法。它可以用来解决图论问题，如最短路径、最小生成树、网络流等。用户可以输入图的结构和权重，然后选择所需的算法进行计算，最后得到相应的结果。该软件可以帮助...
代码随想录算法训练营Day 62| 图论 part02 | 695. 岛屿的最大面积、1020.飞地的数量、130.被围绕的区域
m0_51759998的博客
07-12 534
其实就是从边缘遍历，不是整幅图遍历，最后边缘能遍历到的就都visited=True了，剩下的False且为陆地的就是飞地。
图论第二天|695. 岛屿的最大面积 1020. 飞地的数量 130. 被围绕的区域 417. 太平洋大西洋水流问题 827.最大人工岛
qq_55232233的博客
01-28 593
图论第二天打卡，整体来说套路感挺重的，理解和做起来挺简单的，但写多了也头晕哈哈，加油！思路：dfs，先用map记录原有的每块陆地的大小，再在0处遍历连接陆地，选择最大值。思路：注意终止条件 if (visited[x][y]) return;
代码随想录| 图论02●695岛屿最大面积 ●1020飞地的数量 ●130被围绕的区域 ●417太平洋大西洋水流问题
weixin_51674457的博客
07-21 476
分内陆和外陆，都先从外陆下手，可以使用多种char来标记 使用两个visited表是个技巧
图论算法(6)：LeetCode 图论算法练习（785.判断二分图、695.岛屿的最大面积、Floodfill 算法、并查集）
weixin_43728138的博客
07-22 502
本章节内容使用 java 实现，Github 代码仓：https://github.com/ZhekaiLi/Code/tree/main/Graph/src 查看文章内的图片可能需要科学上网！ 因为使用了github管理图片，因此如果出现无法加载的情况请翻墙 【参考资料】imooc 波波老师：玩转算法系列–图论精讲 面试升职必备（Java版） 【往期博客链接】 图论算法(1、2)：图的分类、图的基本概念（无向图与有向图、无权图、无环图、完全图、二分图；简单图、连通分量、图的生成树、子图与母图） 图论算法(
代码随想录图论|130. 被围绕的区域 417太平洋大西洋水流问题
weixin_44925329的博客
11-16 1141
*题目：**给你一个 m x n 的矩阵 board ，由若干字符 ‘X’ 和 ‘O’ ，找到所有被 ‘X’ 围绕的区域，并将这些区域里所有的 ‘O’ 用 ‘X’ 填充。解题思路：在飞地的基础上做改动，使用一个栈存储需要改变的节点。
算法学习——LeetCode力扣图论篇2（1020. 飞地的数量、130. 被围绕的区域、827. 最大人工岛）
拉依达不拉跨的博客
03-30 1078
算法学习——LeetCode力扣图论篇2（1020. 飞地的数量、130. 被围绕的区域、827. 最大人工岛）
代码随想录训练营补充｜图论｜Golang
weixin_42161901的博客
11-13 517
笔记
图论系列(dfs岛屿) 9/26
2301_78191305的博客
09-26 538
在相同的位置处，如果矩阵2中是陆地，矩阵1中是海洋。1.出现在矩阵边缘的O定不会被包围，首先寻找未被包围的‘O’,通过dfs边缘的O，寻找连通子块。如果该节点正好是1并且没有被访问过，返回true，周围是1，满足被包围的条件。因为1是陆地，所以将两个岛屿中的1相加起来，如果为2，这就是他们重叠的陆地。2.然后剩下的O就是被包围的，将他们标记成X；淹没完不是子岛屿的岛屿，剩下的就是子岛屿的岛屿。如果值为2的岛屿中含有值为1的陆地，那么他就不是子岛屿；给定两个岛屿，看岛屿b中的岛屿是不是岛屿a中的子岛屿。
图论基础及应用.pdf
09-30
以下是对图论基础及应用的详细阐述。 1.1 图的基本概念 在图论中，"图"由一组点（顶点）和连接这些点的线（边）组成。这些点可以代表任何实体，比如城市、节点、设备等，而边则代表它们之间的关系，如道路、通信...
tl.rar_图论基础
09-21
在计算机科学中，图论被广泛应用于网络设计、数据结构、算法分析等多个领域。"tl.rar_图论基础"这个压缩包显然是针对图论初学者设计的，包含了基本概念和入门知识。 在图论中，一个图由顶点（或节点）和边组成。...
图论排队论.zip模型算法MATLAB常用数学模型及建模方法源程序代码下载
05-04
图论排队论.zip模型算法MATLAB常用数学模型及建模方法源程序代码下载图论排队论.zip模型算法MATLAB常用数学模型及建模方法源程序代码下载图论排队论.zip模型算法MATLAB常用数学模型及建模方法源程序代码下载图论排队...
图论模拟试题3.pdf
10-07
"图论模拟试题3.pdf" 图论是数学的一个分支，研究图结构和图的性质，它有广泛的应用于计算机科学、信息科学、生物信息学、社会网络、物流等领域。下面是对图论模拟试题3.pdf中的知识点的总结和解释： 一、图论基础...
图论(dfs系列) 9/27
2301_78191305的博客
09-27 988
2.将所有的连通块找出来之后，然后枚举所有的海洋块。判断海洋块的周围有没有两个连通块(最多只能有两个连通块)。在以往的dfs搜索中，都是往四个方向去dfs；但是在这一道题中，四个方向是不行的；如果第i次是从左往右过来的，那么i+1次，就不能从右往左再过。给定一个二维数组grid,如果二维数组中存在一个环，处于环上的值都是相同的。如果不存在就返回false；1.首先找到所有的岛屿(连通块)，将他们存储到map表中。如果上一次不是从左边来的，那我们就可以往左走；如果上一次不是从右边来的，那我们就可以往右走；
Studying-图论包含的算法总结
yachihaoteng的博客
09-26 831
图论包含的算法总结
图论(bfs系列)9/30
最新发布
2301_78191305的博客
09-30 814
1.首先我们将所有值为1的点都加入到队列中，然后将值为0的点的值都改为-1；（为什么是step-1呢，因为在最后一次查找的时候，已经无法再向外层扩展了，但还是++，所以最后返回的时候应该再减去1）1.首先，这是一个单源点的bfs搜索题，for循环不断遍历每一次搜索能到达的点，然后把这些点加入queue队列中。多源点问题：1.首先将所有的值为1的点都加入队列中，然后将值为0的点赋值为不能达到的值。我们可以计算1到最近的0的距离的最大值。2.然后判断矩阵的规格，如果是1*1的矩阵，直接返回1；
算法打卡：第十一章 图论part10
qq_56221558的博客
09-29 468
代码随想录打卡第60天
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值