代码随想录打卡第五十三天

zengy5

于 2024-08-12 12:11:20 发布

阅读量494

点赞数 15

分类专栏：代码随想录刷题流程文章标签：图论算法数据结构 leetcode c++

本文链接：https://blog.csdn.net/weixin_48013375/article/details/141124265

版权

代码随想录刷题流程专栏收录该内容

46 篇文章 0 订阅

订阅专栏

代码随想录–图论部分

day 53 图论第三天

文章目录

代码随想录--图论部分
一、卡码网101--孤岛的总面积
二、卡码网102--沉没孤岛
三、卡码网103--水流问题
四、卡码网104--建造最大岛屿

一、卡码网101–孤岛的总面积

代码随想录题目链接：代码随想录

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

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

将那些与边界相接触的岛全部变成0，那么剩下的就是孤立的岛屿，遍历相加即可

所以遍历顺序也有说法，不再是从左到右从上到下，而是只搜索边界

当边界有1，那么说明这里有个岛屿接触边界了，要把这整个岛屿删了

代码如下：

#include <iostream>
#include <vector>

using namespace std;
void dfs(vector<vector<int>> & graph, int i, int j)
{
    int rows = graph.size();
    int cols = graph[0].size();
    
    if(i < 0 || j < 0 || i >= rows || j >= cols || !graph[i][j]) return;
    
    graph[i][j] = 0;
    
    dfs(graph, i - 1, j);
    dfs(graph, i + 1, j);
    dfs(graph, i, j - 1);
    dfs(graph, i, j + 1);
    
}


int main()
{
    int n,m;
    cin >> n >> m;
    vector<vector<int>> graph(n, vector<int>(m, 0));
    for(int i = 0; i < n; i ++)
        for(int j = 0; j < m; j ++)
            cin >> graph[i][j];
    
    
    for(int i = 0; i < n; i ++)
    {
        if(graph[i][0]) dfs(graph, i, 0);
        if(graph[i][m - 1]) dfs(graph, i, m - 1);
    }
    for(int i = 0; i < m; i ++)
    {
        if(graph[0][i]) dfs(graph, 0, i);
        if(graph[n - 1][i]) dfs(graph, n - 1, i);
    }
    
    int result = 0;
    for(int i = 0; i < n; i ++)
        for(int j = 0; j < m; j ++)
            if(graph[i][j]) result++;
    
    cout << result << endl;
    
}

二、卡码网102–沉没孤岛

代码随想录题目链接：代码随想录

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

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

和上题一样，只需要在边界搜索时记录下来非孤立岛屿的位置

后续输出即可

代码如下：

#include <iostream>
#include <vector>

using namespace std;

vector<vector<int>> result;
void dfs(vector<vector<int>> & graph, int i, int j)
{
    int rows = graph.size();
    int cols = graph[0].size();
    
    if(i < 0 || j < 0 || i >= rows || j >= cols || !graph[i][j]) return;
    
    graph[i][j] = 0;
    result.push_back({i, j});
    
    dfs(graph, i - 1, j);
    dfs(graph, i + 1, j);
    dfs(graph, i, j - 1);
    dfs(graph, i, j + 1);
    
}


int main()
{
    int n,m;
    cin >> n >> m;
    vector<vector<int>> graph(n, vector<int>(m, 0));
    for(int i = 0; i < n; i ++)
        for(int j = 0; j < m; j ++)
            cin >> graph[i][j];
    

    for(int i = 0; i < n; i ++)
    {
        if(graph[i][0] == 1) dfs(graph, i, 0);
        if(graph[i][m - 1] == 1) dfs(graph, i, m - 1);
    }
    
    for(int i = 0; i < m; i ++)
    {
        if(graph[0][i] == 1) dfs(graph, 0, i);
        if(graph[n - 1][i] == 1) dfs(graph, n - 1, i);
    }
    
    
    vector<vector<int>> graph_out(n, vector<int>(m, 0));
    for(auto ele : result)
    {
        graph_out[ele[0]][ele[1]] = 1;
    }
    for(int i = 0; i < n; i ++)
    {
        for(int j = 0; j < m; j ++)
        {
            cout << graph_out[i][j] << " ";
        }        
        cout << endl;
    }
    
}

三、卡码网103–水流问题

代码随想录题目链接：代码随想录

现有一个 N × M 的矩阵，每个单元格包含一个数值，这个数值代表该位置的相对高度。矩阵的左边界和上边界被认为是第一组边界，而矩阵的右边界和下边界被视为第二组边界。

矩阵模拟了一个地形，当雨水落在上面时，水会根据地形的倾斜向低处流动，但只能从较高或等高的地点流向较低或等高并且相邻（上下左右方向）的地点。我们的目标是确定那些单元格，从这些单元格出发的水可以达到第一组边界和第二组边界。

也就是需要找到某些单元格，按照元素递减的顺序能够到达左/上边界以及右/下边界

在这里插入图片描述

则可以从两个边界分别开始遍历，记录每个节点能够到达的地点

保存两个边界分别能遍历到的节点，重叠的部分就是需要输出的结果

代码如下：

#include <iostream>
#include <vector>

using namespace std;

vector<pair<int, int>> directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

void dfs(vector<vector<int>> & graph, vector<vector<int>> & border, int i, int j)
{

    if(border[i][j]) return;
    
    border[i][j] = 1;
    
    int rows = graph.size();
    int cols = graph[0].size();
    
    for(auto ele : directions)
    {
        int x = i + ele.first;
        int y = j + ele.second;
        if(x < 0 || y < 0 || x >= rows || y >= cols) continue;
        if(graph[i][j] <= graph[x][y]) dfs(graph, border, x, y);
    }
    
}
int main()
{
    int n, m;
    cin >> n >> m;
    vector<vector<int>> graph(n, vector<int>(m, 0));
    for(int i = 0;i < n; ++ i)
        for(int j = 0; j < m; ++j)
            cin >> graph[i][j];
    
    vector<vector<int>> first(n, vector<int>(m, 0));
    vector<vector<int>> second(n, vector<int>(m, 0));
    
    for(int i = 0; i < n ; ++ i)
    {
        dfs(graph, first, i, 0);
        dfs(graph, second, i, m - 1);
    }
    
    for(int i = 0; i < m ; ++ i)
    {
        dfs(graph, first, 0, i);
        dfs(graph, second, n - 1, i);
    }
    
    for(int i = 0;i < n; ++ i)
        for(int j = 0; j < m; ++j)
            if(first[i][j] && second[i][j]) 
                cout << i << " "<< j << endl; 

    
    return 0;
}

四、卡码网104–建造最大岛屿

代码随想录题目链接：代码随想录

给定一个由 1（陆地）和 0（水）组成的矩阵，你最多可以将矩阵中的一格水变为一块陆地，在执行了此操作之后，矩阵中最大的岛屿面积是多少。

岛屿面积的计算方式为组成岛屿的陆地的总数。岛屿是被水包围，并且通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设矩阵外均被水包围。

暴力法就是遍历，每次改成0后就算一次最大岛屿面积，取遍历结束的最大值，自然是超时

实际上可以记录每个岛的大小，再遍历每个0点，计算如果它周围链接岛屿的面积和

#include <iostream>
#include <vector>
#include <unordered_set>
#include <unordered_map>
using namespace std;
int n, m;
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, int mark) {
    if (visited[x][y] || grid[x][y] == 0) return; // 终止条件：访问过的节点 或者 遇到海水
    visited[x][y] = true; // 标记访问过
    grid[x][y] = mark; // 给陆地标记新标签
    count++;
    for (int i = 0; i < 4; i++) {
        int nextx = x + dir[i][0];
        int nexty = y + dir[i][1];
        if (nextx < 0 || nextx >= n || nexty < 0 || nexty >= m) continue;  // 越界了，直接跳过
        dfs(grid, visited, nextx, nexty, mark);
    }
}

int main() {
    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)); // 标记访问过的点
    unordered_map<int ,int> gridNum;
    int mark = 2; // 记录每个岛屿的编号
    bool isAllGrid = true; // 标记是否整个地图都是陆地
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (grid[i][j] == 0) isAllGrid = false;
            if (!visited[i][j] && grid[i][j] == 1) {
                count = 0;
                dfs(grid, visited, i, j, mark); // 将与其链接的陆地都标记上 true
                gridNum[mark] = count; // 记录每一个岛屿的面积
                mark++; // 记录下一个岛屿编号
            }
        }
    }
    if (isAllGrid) {
        cout << n * m << endl; 
        return 0;
    }

    int result = 0; 
    unordered_set<int> visitedGrid; 
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            count = 1; 
            visitedGrid.clear(); 
            if (grid[i][j] == 0) {
                for (int k = 0; k < 4; k++) {
                    int neari = i + dir[k][1]; 
                    int nearj = j + dir[k][0];
                    if (neari < 0 || neari >= n || nearj < 0 || nearj >= m) continue;
                    if (visitedGrid.count(grid[neari][nearj])) continue; 
                    count += gridNum[grid[neari][nearj]];
                    visitedGrid.insert(grid[neari][nearj]); 
                }
            }
            result = max(result, count);
        }
    }
    cout << result << endl;

}