代码随想录第六十二天——岛屿数量，岛屿的最大面积，飞地的数量

最新推荐文章于 2024-08-05 16:19:50 发布
最新推荐文章于 2024-08-05 16:19:50 发布
阅读量448 收藏 8
点赞数 9
分类专栏： leetcode训练——代码随想录 文章标签： 数据结构 算法 深度优先 广度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39088868/article/details/135609084
版权

leetcode 200. 岛屿数量

题目链接：岛屿数量
本题思路，是用遇到一个没有遍历过的节点陆地，计数器就加一，然后把该节点陆地所能遍历到的陆地都标记上。在遇到标记过的陆地节点和海洋节点的时候直接跳过。 这样计数器就是最终岛屿的数量

方法一：深度优先搜索

版本一：

class Solution {
private:
    int dir[4][2] = {0,1,1,0,-1,0,0,-1}; //四个方向
    void dfs(vector<vector<char>>& 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;
            dfs(grid,visited,nextx,nexty);
        }
      }
    }
public:
    int numIslands(vector<vector<char>>& grid) {
         int n = grid.size(), m = grid[0].size();
        vector<vector<bool>> visited = vector<vector<bool>>(n, vector<bool>(m, false)); 
        int res=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(!visited[i][j] && grid[i][j]=='1'){
                   visited[i][j] = true;
                    res++; // 遇到没访问过的陆地，+1 
                    dfs(grid, visited, i, j); // 将与其链接的陆地都标记上 true
                }
            }
        }
       return res;        
    }
};

版本二：

// 版本二
class Solution {
private:
    int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; //四个方向
    void dfs(vector<vector<char>>& grid, vector<vector<bool>>& visited, int x, int y) {
        if (visited[x][y] || grid[x][y] == '0') return; //终止条件：访问过的节点或者遇到海水
        visited[x][y] = true; //标记访问过
        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;  //越界了，直接跳过
            dfs(grid, visited, nextx, nexty);
        }
    }
public:
    int numIslands(vector<vector<char>>& grid) {
        int n = grid.size(), m = grid[0].size();
        vector<vector<bool>> visited = vector<vector<bool>>(n, vector<bool>(m, false));
        int res = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (!visited[i][j] && grid[i][j] == '1') {
                    res++; //遇到没访问过的陆地，+1
                    dfs(grid, visited, i, j); //将与其链接的陆地都标记上 true
                }
            }
        }
        return result;
    }
};

方法二：广度优先搜索

只要加入队列就代表走过，就需要标记，而不是从队列拿出来的时候再去标记走过。

class Solution {
private:
int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向
void bfs(vector<vector<char>>& grid, vector<vector<bool>>& visited, int x, int y) {
    queue<pair<int, int>> que;
    que.push({x, y});
    visited[x][y] = true; //只要加入队列，立刻标记
    while(!que.empty()) {
        pair<int ,int> cur = que.front(); que.pop();
        int curx = cur.first;
        int cury = cur.second;
        for (int i = 0; i < 4; i++) {
            int nextx = curx + dir[i][0];
            int nexty = cury + dir[i][1];
            if (nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue;  // 越界了，直接跳过
            if (!visited[nextx][nexty] && grid[nextx][nexty] == '1') {
                que.push({nextx, nexty});
                visited[nextx][nexty] = true; // 只要加入队列立刻标记
            }
        }
    }
}
public:
    int numIslands(vector<vector<char>>& grid) {
        int n = grid.size(), m = grid[0].size();
        vector<vector<bool>> visited = vector<vector<bool>>(n, vector<bool>(m, false));
        int res= 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (!visited[i][j] && grid[i][j] == '1') {
                    res++; // 遇到没访问过的陆地，+1
                    bfs(grid, visited, i, j); //将与其链接的陆地都标记上true
                }
            }
        }
        return re;
    }
};

leetcode 695. 岛屿的最大面积

方法一：深度优先搜索

版本一：

class Solution {
private:
    int count;
    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);
            }
        }
    }

public:
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size();
        vector<vector<bool>> visited = vector<vector<bool>>(n, vector<bool>(m, false));
        int res = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (!visited[i][j] && grid[i][j] == 1) {
                    count = 1;  // 因为dfs处理下一个节点，所以这里遇到陆地了就先计数，dfs处理接下来的相邻陆地
                    visited[i][j] = true;
                    dfs(grid, visited, i, j); // 将与其链接的陆地都标记上 true
                    res = max(res, count);
                }
            }
        }
        return res;
    }
};

版本二：

class Solution {
private:
    int count;
    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) {
        if (visited[x][y] || grid[x][y] == 0) return; // 终止条件：访问过的节点 或者 遇到海水
        visited[x][y] = true; // 标记访问过
        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;  // 越界了，直接跳过
            dfs(grid, visited, nextx, nexty);
        }
    }

public:
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size();
        vector<vector<bool>> visited = vector<vector<bool>>(n, vector<bool>(m, false));
        int res = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (!visited[i][j] && grid[i][j] == 1) {
                    count = 0; // 因为dfs处理当前节点，所以遇到陆地计数为0，进dfs之后在开始从1计数
                    dfs(grid, visited, i, j); // 将与其链接的陆地都标记上 true
                    res = max(res, count);
                }
            }
        }
        return res;
    }
};

方法二：广度优先搜索

class Solution {
private:
    int count;
    int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; //四个方向
    void bfs(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);
                }
            }
        }
    }
public:
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size();
        vector<vector<bool>> visited = vector<vector<bool>>(n, vector<bool>(m, false));
        int res = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (!visited[i][j] && grid[i][j] == 1) {
                    count = 0;
                    bfs(grid, visited, i, j); // 将与其链接的陆地都标记上 true
                    res = max(res, count);
                }
            }
        }
        return res;
    }
};

leetcode 1020. 飞地的数量

题目链接：飞地的数量
本题要求找到不靠边的陆地面积，只要从周边找到陆地然后通过dfs或者bfs将周边靠陆地且相邻的陆地都变成海洋，然后再去重新遍历地图，统计此时还剩下的陆地。

方法一：深度优先搜索

class Solution {
private:
    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] == 0) continue;
            dfs (grid, nextx, nexty);
        }
        return;
    }
public:
    int numEnclaves(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size();
        //从左侧边，和右侧边向中间遍历
        for (int i = 0; i < n; i++) {
            if (grid[i][0] == 1) dfs(grid, i, 0);
            if (grid[i][m - 1] == 1) dfs(grid, i, m - 1);
        }
        //从上边和下边向中间遍历
        for (int j = 0; j < m; j++) {
            if (grid[0][j] == 1) dfs(grid, 0, j);
            if (grid[n - 1][j] == 1) 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] == 1) dfs(grid, i, j);
            }
        }
        return count;
    }
};

方法二：广度优先搜索

class Solution {
private:
int count = 0;
int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向
void bfs(vector<vector<int>>& grid, int x, int y) {
    queue<pair<int, int>> que;
    que.push({x, y});
    grid[x][y] = 0; //只要加入队列，立刻标记
    count++;
    while(!que.empty()) {
        pair<int ,int> cur = que.front(); que.pop();
        int curx = cur.first;
        int cury = cur.second;
        for (int i = 0; i < 4; i++) {
            int nextx = curx + dir[i][0];
            int nexty = cury + dir[i][1];
            if (nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue;  // 越界了，直接跳过
            if (grid[nextx][nexty] == 1) {
                que.push({nextx, nexty});
                count++;
                grid[nextx][nexty] = 0; //只要加入队列立刻标记
            }
        }
    }
}
public:
    int numEnclaves(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size();
        //从左侧边，和右侧边向中间遍历
        for (int i = 0; i < n; i++) {
            if (grid[i][0] == 1) bfs(grid, i, 0);
            if (grid[i][m - 1] == 1) bfs(grid, i, m - 1);
        }
        //从上边和下边向中间遍历
        for (int j = 0; j < m; j++) {
            if (grid[0][j] == 1) bfs(grid, 0, j);
            if (grid[n - 1][j] == 1) 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] == 1) bfs(grid, i, j);
            }
        }
        return count;
    }
};
荒野饮冰室
关注
专栏目录
C++——岛屿数量
一抹阳光的博客
05-26 2075
在遍历数组的过程中，若当前位置上的字符为“1”，首先将岛屿数量加一，然后将该位置的字符设为“0”并搜索该位置的上下左右位置，若为1，则置“0”并继续搜索直到四周都为0，为止，继续遍历重复此操作。 说明（因为连着的陆地算一个岛屿，因此当我们遍历到“1”时，需要搜索1周围是否存在“1”可以连成一个岛屿，直到找不到相连的陆地为止，同时将这些搜索过的置为“0”，避免后面遍历的时候重复计算。 代码如下： class Solution { public: /** * 判断岛屿数量 ...
《代码随想录》最新PDF全集整理发布
最新发布
09-17
内容概要：这是关于作者针对自己的代码学习笔记《代码随想录》，进行两年后的全面更新与汇总的一则公告。新的PDF版本整合了所有最新内容，并修复和完善了一系列题目解释。尽管如此，作者仍推荐优先在网站上阅读以...
LC 岛屿数量(C++ 实现)
明天，做什么好呢
10-08 841
问题描述 给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围 示例 1. 输入 [ [‘1’,‘1’,‘1’,‘1’,‘0’], [‘1’,‘1’,‘0’,‘1’,‘0’], [‘1’,‘1’,‘0’,‘0’,‘0’], [‘0’,‘0’,‘0’,‘0’,‘0’] ] 输出: 1 2. 输入 [ [‘1’,‘1’,‘0’,‘0’,‘0’], [‘1’,
LeetCode数据结构—岛屿数量的广度优先搜索C++实现
郡酱的博客~
08-18 804
一、广度优先搜索（BFS: Breadth-First-Search） 1.1 BFS的概念 广度优先算法是一种图形搜索算法。从图的某一结点出发，首先依次访问该结点的所有邻接顶点Vi1,Vi2,...VinVi_1,Vi_2,...Vi_nVi1​,Vi2​,...Vin​再按这些顶点被访问的先后次序依次访问与它们相邻接的所有未被访问的顶点。重复此过程直至所有顶点均被访问为止。 ![在这里插入图...
岛屿个数c++
m0_68416190的博客
04-09 436
遍历二维数组，遇到一块陆地‘1’，那么就把包含这块陆地的岛屿用bfs_islands函数搜索一遍，并标记这些块已经被搜索过了。然后，“派一些船”从该岛屿上一块陆地的八个方向出发，让船在海水上行驶，如果有船能到达“世界边缘”，那么说明该岛屿没有被包围。注意岛屿 33 并不是岛屿 11 或者岛屿 22 的子岛屿，因为岛屿 11 和岛屿 22 中均没有“环”。岛屿 22 在岛屿 11 的 “环” 内部，所以岛屿 22 是岛屿 11 的子岛屿，答案为 11。最外层加一圈海水，这一圈海水即为世界边缘。
岛屿数量（C++牛客网）
coolsunxu的博客
04-09 191
岛屿数量（C++牛客网）
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
代码随想录知识算法讲解PDF
10-26
代码随想录贪心算法知识，非常管用
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
《代码随想录》是一本深受程序员喜爱的编程学习资料，尤其在算法领域，它提供了丰富的实例和深入的解析，帮助读者理解并掌握动态规划、回溯、递归、二叉树以及贪心等核心算法。这些算法是解决复杂计算问题的基础工具...
代码随想录+刷题笔记记录
03-22
代码随想录是一个致力于帮助程序员提高编程能力的网站，提供了大量的题目和解题思路供学习和参考。本文主要介绍代码随想录的刷题笔记记录，方便读者更好地利用该网站进行学习。 ## 刷题笔记记录的作用 刷题笔记...
岛屿数量（C++）（DFS）（遍历所有点）
weixin_52120741的博客
04-21 794
题目描述 给一个01矩阵，1代表是陆地，0代表海洋，如果两个1相邻，那么这两个1属于同一个岛。我们只考虑上下左右为相邻。 岛屿: 相邻陆地可以组成一个岛屿（相邻:上下左右） 判断岛屿个数。 示例1 输入 [[1,1,0,0,0],[0,1,0,1,1],[0,0,0,1,1],[0,0,0,0,0],[0,0,1,1,1]] 返回值 3 1、考察：类似城堡问题，遍历所有点 2、更改grid[i][j]的值，来表示是否被访问过 class Solution { public: .
LeetCode第 200 题：岛屿数量(C++)
zj
08-28 530
200. 岛屿数量 - 力扣（LeetCode） 类似LeetCode第 130 题：被围绕的区域(C++)_zj-CSDN博客 dfs 要向四个方向遍历，一开始以为三个方向就可以，后来才发现可能需要向上的 class Solution { public: int res = 0; int numIslands(vector<vector<char>>& grid) { if(grid.empty()) return res;
LeetCode 200. 岛屿数量(C++)
Xavier_97的博客
09-11 2422
思路：我们从题目中可以得知，孤立的岛屿旁边全是海，假设岛屿范围内每一个‘1’是岛屿的一部分，那么我们从岛屿的任意一部分登岛，走遍岛屿的每一块土地，就能确定岛屿的大小和范围。为了找遍所有的岛屿，我们还需要把走过的土地都标记为0，防止从同一岛屿的另一部分登岛。记录岛屿的数量加1，再继续找还没有'1'的部分，走遍下一个岛屿。比如下面的例子，不同颜色的'1'表示不同岛屿的一部分。对于这道题来说，广度优先遍历值得注意的地方在于，要先把当前出队的元素上下左右置0（若有岛屿部分），然后再把那些置过0的元素入队。
LeetCode 200.岛屿数量 C++
麦当劳比肯德基好吃
08-23 317
题目描述 给你一个由'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： 输入：gr...
LeetCode 200. Number of Islands 岛屿数量(C++)
kngines
04-26 238
写在前面 持续刷题学习ing 出来混迟早都要还的，还大学期间欠下的算法债，，， 刷题过程中，暂不考虑性能等，以方法便捷、有效为准 试题详情 试题描述 给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。 测试用例 input:...
C++解决《岛屿数量》问题（DFS）
lzq8090的博客
03-23 1355
No.200《岛屿数量》；类型：DFS1.题目：2.题解思想3.题解代码 1.题目： 给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。 示例 1： 输入：grid = [ [“1”,“1”,“1”,“1”,“0”], [“1”,“1”,“0”,“1”,“0”], [“1”,“1”,“0”,“0”,“0”], [“0”,“0”,“0”,“0”,“0
Leetcode: 岛屿数(Number of Islands)(C++)
qq_30811835的博客
04-30 251
Given a 2d grid map of'1's (land) and'0's (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume...
NC109 岛屿数量
MaopengLee的博客
07-19 341
题目描述： 给一个01矩阵，1代表是陆地，0代表海洋， 如果两个1相邻，那么这两个1属于同一个岛。我们只考虑上下左右为相邻。 岛屿: 相邻陆地可以组成一个岛屿（相邻:上下左右） 判断岛屿个数。 解题分析： 使用dfs遍历即可。 class Solution { public: /** * 判断岛屿数量 * @param grid char字符型vector<vector<>> * @return int整型 */ int so
leetcode200. 岛屿数量C++题解，附思维导图和流程图，一题带你弄懂图的dfs遍历算法
qq_51350957的博客
08-05 2798
leetcode200. 岛屿数量C++题解，附思维导图和流程图，一题带你弄懂图的dfs遍历算法
代码随想录python
02-17
代码随想录是一个由CSDN开发的Python学习教程，它提供了丰富的Python编程知识和实例代码。以下是关于代码随想录Python的介绍： 1. 代码随想录Python是一个面向初学者的Python教程，它从基础知识开始，逐步介绍...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值