代码随想录：图论_02岛屿问题

于 2024-07-17 00:35:07 发布
阅读量180 收藏 4
点赞数 1
文章标签： 深度优先 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51503393/article/details/140409737
版权

99. 岛屿数量

给定一个由 1（陆地）和 0（水）组成的矩阵，你需要计算岛屿的数量。岛屿由水平方向或垂直方向上相邻的陆地连接而成，并且四周都是水域。你可以假设矩阵外均被水包围。

输入描述

第一行包含两个整数 N, M，表示矩阵的行数和列数。
 后续 N 行，每行包含 M 个数字，数字为 1 或者 0。

输出描述

> 输出一个整数，表示岛屿的数量。如果不存在岛屿，则输出 0。

输入示例

4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1

输出示例

3
深度优先搜索
#include<bits/stdc++.h>
using namespace std;
int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向
void dfs(const 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; // 标记访问过
    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);
    }
}
int main(){
    int n, m;
    cin >> n >> m;
    vector<vector<int>> grid(n, vector<int>(m, 0));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> grid[i][j];
        }
    }
    vector<vector<bool>> visited(n, vector<bool>(m, false));
    int result = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (!visited[i][j] && grid[i][j] == 1) {
                result++; // 遇到没访问过的陆地，+1
                dfs(grid, visited, i, j); // 将与其链接的陆地都标记上 true
            }
        }
    }

    cout << result << endl;
    return 0;
}
广度优先搜索
#include<bits/stdc++.h>
using namespace std;
int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向
void bfs(const vector<vector<int>>& 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; // 只要加入队列立刻标记
            }
        }
    }
}
int main(){
    int n, m;
    cin >> n >> m;
    vector<vector<int>> grid(n, vector<int>(m, 0));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> grid[i][j];
        }
    }
    vector<vector<bool>> visited(n, vector<bool>(m, false));
    int result = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (!visited[i][j] && grid[i][j] == 1) {
                result++; // 遇到没访问过的陆地，+1
                bfs(grid, visited, i, j); // 将与其链接的陆地都标记上 true
            }
        }
    }

    cout << result << endl;
    return 0;
}

100. 岛屿的最大面积

题目描述

给定一个由 1（陆地）和 0（水）组成的矩阵，计算岛屿的最大面积。岛屿面积的计算方式为组成岛屿的陆地的总数。岛屿由水平方向或垂直方向上相邻的陆地连接而成，并且四周都是水域。你可以假设矩阵外均被水包围。

输入描述

第一行包含两个整数 N, M，表示矩阵的行数和列数。后续 N 行，每行包含 M 个数字，数字为 1 或者 0，表示岛屿的单元格。

输出描述

输出一个整数，表示岛屿的最大面积。如果不存在岛屿，则输出 0。

输入示例

4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1

输出示例

4
深度优先搜索
#include<bits/stdc++.h>
using namespace std;
int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向
void dfs(const vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y,int& s) {
    if (visited[x][y] || grid[x][y] == 0) return; // 终止条件：访问过的节点 或者 遇到海水
    s++;
    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, s);
    }
}
int main(){
    int n, m;
    cin >> n >> m;
    vector<vector<int>> grid(n, vector<int>(m, 0));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> grid[i][j];
        }
    }
    vector<vector<bool>> visited(n, vector<bool>(m, false));
    int maxs = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (!visited[i][j] && grid[i][j] == 1) {
                int s = 0; // 遇到没访问过的陆地，+1
                dfs(grid, visited, i, j, s); // 将与其链接的陆地都标记上 true
                maxs = max(maxs, s); 
            }
        }
    }
    cout << maxs << endl;
    return 0;
}
广度优先搜索
#include<bits/stdc++.h>
using namespace std;
int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向
void bfs(const vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y, int& s) {
    queue<pair<int,int>> que;
    que.push({x, y});
    s++;
    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) {
                s++;
                que.push({nextx, nexty});
                visited[nextx][nexty] = true; // 只要加入队列立刻标记
            }
        }
    }
}
int main(){
    int n, m;
    cin >> n >> m;
    vector<vector<int>> grid(n, vector<int>(m, 0));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> grid[i][j];
        }
    }
    vector<vector<bool>> visited(n, vector<bool>(m, false));
    int result = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (!visited[i][j] && grid[i][j] == 1) {
                int s = 0; // 遇到没访问过的陆地，+1
                bfs(grid, visited, i, j, s); // 将与其链接的陆地都标记上 true
                result = max(result, s);
            }
        }
    }

    cout << result << endl;
    return 0;
}

101. 孤岛的总面积

题目描述

给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿指的是由水平或垂直方向上相邻的陆地单元格组成的区域，且完全被水域单元格包围。孤岛是那些位于矩阵内部、所有单元格都不接触边缘的岛屿。

现在你需要计算所有孤岛的总面积，岛屿面积的计算方式为组成岛屿的陆地的总数。

输入描述

第一行包含两个整数 N, M，表示矩阵的行数和列数。之后 N 行，每行包含 M 个数字，数字为 1 或者 0。

输出描述

输出一个整数，表示所有孤岛的总面积，如果不存在孤岛，则输出 0。

输入示例

4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1

输出示例

1
深度优先搜索 
#include<bits/stdc++.h>
using namespace std;
int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1};//四个方向
int res;
void dfs(vector<vector<int>>& grid, int x, int y){
    grid[x][y] = 0;
    res++;
    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;
}
int main(){
    int n, m;
    cin >> n >> m;
    vector<vector<int>> grid(n, vector<int>(m));
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            cin >> grid[i][j];
        }
    }
    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);
    }
    res = 0;
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            if(grid[i][j] == 1)
                res++;
        }
    }
    cout << res << endl;
    return 0;
}
广度优先搜索 
#include<bits/stdc++.h>
using namespace std;
int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1};//四个方向
int res;
void bfs(vector<vector<int>>& grid, int x, int y){
   queue<pair<int,int>> que;
   que.push({x, y});
   grid[x][y] = 0;
   res++;
   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});
                res++;
                grid[nextx][nexty] = 0;
            }
       }
   }
}
int main(){
    int n, m;
    cin >> n >> m;
    vector<vector<int>> grid(n, vector<int>(m));
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            cin >> grid[i][j];
        }
    }
    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);
    }
    res = 0;
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            if(grid[i][j] == 1)
                res++;
        }
    }
    cout << res << endl;
    return 0;
}

102. 沉没孤岛

题目描述

给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿指的是由水平或垂直方向上相邻的陆地单元格组成的区域，且完全被水域单元格包围。孤岛是那些位于矩阵内部、所有单元格都不接触边缘的岛屿。

现在你需要将所有孤岛“沉没”，即将孤岛中的所有陆地单元格（1）转变为水域单元格（0）。

输入描述

第一行包含两个整数 N, M，表示矩阵的行数和列数。

之后 N 行，每行包含 M 个数字，数字为 1 或者 0，表示岛屿的单元格。

输出描述

输出将孤岛“沉没”之后的岛屿矩阵。 注意：每个元素后面都有一个空格

输入示例

4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1

输出示例

1 1 0 0 0
1 1 0 0 0
0 0 0 0 0
0 0 0 1 1
深度优先搜索 
#include<bits/stdc++.h>
using namespace std;
int dir[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1};
void dfs(vector<vector<int>>& grid, int x, int y){
    grid[x][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 (grid[nextx][nexty] == 0 || grid[nextx][nexty] == 2) 
            continue;
        dfs(grid, nextx, nexty);
    }
}
int main(){
    int n, m;
    cin >> n >> m;
    vector<vector<int>> grid(n, vector<int>(m, 0));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> grid[i][j];
        }
    }
    
    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);
    }
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            if(grid[i][j] > 0)
                grid[i][j]--;
            cout << grid[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}
广度优先搜索  
#include<bits/stdc++.h>
using namespace std;
int dir[4][2] = {-1, 0, 0, -1, 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]++;
    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});
                grid[nextx][nexty]++;
            }
        }
    }
}
int main(){
    int n, m;
    cin >> n >> m;
    vector<vector<int>> grid(n, vector<int>(m, 0));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> grid[i][j];
        }
    }
    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);
    }
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            if(grid[i][j] > 0)
                grid[i][j]--;
            cout << grid[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

weixin_51503393
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
代码随想录 面试大厂必备八股文
07-03
《代码随想录》是众多程序员面试准备的重要参考资料，尤其对于目标是大厂的开发者来说，这本书中的“面试大厂必备八股文”更是不容忽视的内容。这里的“八股文”并非传统意义上的文学形式，而是指在编程面试中经常被...
【代码随想录——图论——岛屿问题】
qq_45467608的博客
07-05 360
pid=1171。
代码随想录-图论
m0_71894372的博客
04-04 439
【代码】代码随想录-图论。
代码随想录——钥匙和房间（图论）
qq_39473176的博客
11-17 405
刷题总结
「代码随想录」图论之图的DFS遍历
weixin_44622140的博客
08-14 366
如果把二维矩阵中的每一个位置看做一个节点，这个节点的上下左右四个位置就是相邻节点，那么整个矩阵就可以抽象成一幅网状的「图」结构，使用visited数组来记录节点的访问情况。其实就是遍历二维数组（图）的每个值（节点），如果发现岛屿“1”，就使用DFS将连通的部分全部变为“0”（淹没岛屿），最后返回发现的岛屿数即可。graph[i] 是一个从节点 i 可以访问的所有节点的列表（即从节点 i 到节点 graph[i][j]存在一条有向边）。此处的graph为题目给出的图，root为当前搜索的根节点。
代码随想录知识星球精华 最强⼋股⽂
04-28
代码随想录知识星球精华（最强⼋股⽂） 这份PDF总结了 代码随想录知识星球 的全部精华内容，覆盖了⼏乎程序员学习必备的内容。 知识星球⾥很多录友拿到了⼤⼚offer，包括科班 和 ⾮科班的，⽽他们的每⽇学习总结都是...
代码随想录-大厂八股文-面试
04-25
代码随想录的大厂八股文面试相关知识点非常广泛，包括了编程基础、算法设计、代码组织、问题解决等多方面的知识点。为了通过面试，考察者需要具备扎实的编程基础和实践经验，能够熟练掌握多种编程语言和技术，能够写...
代码随想录算法PDF.zip
05-29
在《代码随想录》中，作者详细介绍了常见算法问题的解决思路和方法，涵盖了数据结构、排序算法、搜索算法等多个方面。以下是书中的部分关键知识点： 1. **基础数据结构**：包括数组、链表、栈、队列、哈希表、树...
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5126
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
函数模板与类模板
程序员_小兵
07-12 1555
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
基于Big-Bang-Big-Crunch(BBBC)算法的目标函数最小值计算matlab仿真
熟悉python,matlab,C,C++,JAVA等
07-12 380
BBBC算法的核心思想模拟了宇宙从大爆炸（Big Bang）开始，经历扩张，再到可能的大收缩（Big Crunch）的过程，以此类比于在解空间中从初始分散的解集出发，通过一系列搜索过程逐步集中并接近最优解的过程。：一个简化的聚集方法可以是xi′′​=xbest​+β⋅(xi′​−xbest​)，其中xbest​是最优解，β是一个小于1的收缩因子，控制收缩速度。：每个解xi​依据一定的规则在解空间中移动，这个移动可以是随机的，也可以基于某种策略，比如基于目标函数梯度的方向或者利用当前解与其他解的相对位置。
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 368
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 763
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
常见的排序算法，复杂度
m0_61544805的博客
07-16 329
稳定 / 非稳定排序：两个相等的数 排序前后 相对位置不变。 插入排序（希尔排序）： 每一趟将一个待排序记录，按其关键字的大小插入到已排好序的一组记录的适当位置上，直到所有待排序记录全部插入为止。稳定，O(n)，O(1)。 把记录按下标增量（模）分组，对每组进行直接插入排序，每次排序后减小增量，当增量减至 1 时排序完毕。不稳定，不知道（有个实验结论），O(1)。 冒泡排序： 比较相邻的元素，如果第一个比第二个大就进行交换，对每一对相邻元素做同样的工作。稳定，O(n)，O(1)。 选择
树与二叉树
2201_76027754的博客
07-15 452
树和二叉树
算法刷题笔记 KMP字符串（C++实现，并给出了求next数组的独家简单理解方式）
hanmo22357的博客
07-12 815
一道经典且较难的算法题，给出了C++代码实现，以及自己对next数组求解的独家简单的理解方式。
拆分整数 java
最新发布
laocooon的博客
07-16 108
输入: n = 10输出: 36解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。输入: n = 2输出: 1解释: 2 = 1 + 1, 1 × 1 = 1。），并使这些整数的乘积最大化。你可以获得的最大乘积。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值