「代码随想录算法训练营」第四十五天 | 图论 part3

news/2024/9/19 9:23:24/文章来源:https://www.cnblogs.com/frontpen/p/18375718

目录
  • 101. 孤岛的总面积
    • DFS思路
    • BFS思路
  • 102. 沉没孤岛
  • 103. 水流问题
  • 104. 建造最大岛屿

101. 孤岛的总面积

题目链接:https://kamacoder.com/problempage.php?pid=1173
文章讲解:https://programmercarl.com/kamacoder/0101.孤岛的总面积.html
题目状态:看题解

DFS思路

思路:

代码结构

  1. 变量和方向数组:

    • dir[4][2]:定义了四个方向的移动(上、左、下、右)。
    • count:用于统计符合条件的陆地块数量。
  2. 深度优先搜索函数 dfs:

    • 输入参数为二维数组 grid 和当前坐标 (x, y)
    • 将当前坐标的值设为 0(表示已访问)。
    • 增加 count 计数。
    • 遍历四个方向,递归调用 dfs,前提是新坐标在边界内且值为 1(表示陆地)。
  3. 主函数 main:

    • 读取网格的大小 nm
    • 初始化一个 n x m 的二维数组 grid
    • 从输入读取网格数据。
    • 从网格的四个边界开始,使用 dfs 清除边界连接的陆地。
    • 重置 count
    • 遍历内部陆地,使用 dfs 统计不与边界相连的陆地块。
    • 输出 count

逻辑分析

  • 边界处理:

    • 先从网格的边界开始,使用 dfs 清除与边界相连的陆地。这样可以排除掉与边界相连的陆地块。
  • 统计孤立陆地:

    • 遍历整个网格,使用 dfs 统计不与边界相连的陆地块。

代码:

#include <iostream>
#include <vector>
using namespace std;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;
}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);}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);}}cout << count << endl;
}

BFS思路

思路:

代码结构

  1. 方向数组 dir

    • 表示四个方向(右、下、左、上)的移动。
    • dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1} 表示:
      • 右:(0, 1)
      • 下:(1, 0)
      • 左:(-1, 0)
      • 上:(0, -1)
  2. 全局变量 count

    • 用于统计符合条件的陆地格子数量。
  3. 广度优先搜索函数 bfs

    • 参数:网格 grid,起始坐标 (x, y)
    • 使用队列 que 来实现BFS。
    • 将起始点标记为访问过(设置为0)并加入队列。
    • 遍历队列中的每个点,向四个方向扩展。
    • 检查边界条件,确保不越界。
    • 对于相邻的陆地格子,标记为访问过并加入队列。
  4. 主函数 main

    • 输入:网格大小 nm,以及网格数据。
    • 初始化网格 grid
    • 从网格的边界开始,移除与边界相连的陆地。
    • 重置 count
    • 遍历整个网格,统计被包围的陆地数量。
    • 输出结果。

逻辑流程

  1. 输入处理

    • 读取网格的大小 nm
    • 读取网格数据,填充 grid
  2. 边界BFS

    • 从网格的四个边界开始,使用 bfs 移除与边界相连的陆地。
    • 这部分陆地不计入最终统计,因为题目可能要求只统计被完全包围的陆地。
  3. 统计被包围的陆地

    • 重置 count
    • 遍历网格内部,使用 bfs 统计所有剩余陆地格子的数量。
  4. 输出结果

    • 打印出符合条件的陆地格子数量。

代码:

#include <iostream>
#include <vector>
#include <queue>
using namespace std;int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 保存四个方向
int count = 0; // 统计符合题目要求的陆地空格数量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.size()) continue; // 越界了,直接跳过if(grid[nextx][nexty] == 1) {que.push({nextx, nexty});count++;grid[nextx][nexty] = 0; // 只要加入队列立刻标记}}}    
}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);}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);}}cout << count << endl;
}

102. 沉没孤岛

题目链接:https://kamacoder.com/problempage.php?pid=1174
文章讲解:https://programmercarl.com/kamacoder/0102.沉没孤岛.html
题目状态:看题解

思路:

代码结构

  1. 方向数组 dir:

    • 定义了四个方向(上、左、下、右)的移动坐标:{-1, 0}{0, -1}{1, 0}{0, 1}
  2. DFS 函数:

    • 参数: 接受一个二维数组 grid 和当前坐标 (x, y)
    • 功能: 将当前陆地标记为 2,并递归遍历四个方向的相邻陆地。
    • 边界条件: 检查是否越界或遇到水(0)或已访问(2)的格子。
  3. 主函数 main:

    • 输入: 从标准输入读取网格大小 nm,以及网格数据。
    • 步骤一: 从边界开始,将与边界相连的陆地(1)通过 DFS 标记为 2。
    • 步骤二: 将剩余的陆地(孤岛)变成水(0)。
    • 步骤三: 将标记为 2 的边界陆地恢复为陆地(1)。
    • 输出: 打印修改后的网格。

逻辑流程

  • 边界处理:

    • 从网格的四条边界开始,使用 DFS 将所有与边界相连的陆地标记为 2。
  • 孤岛处理:

    • 遍历整个网格,将所有未标记为 2 的陆地(即孤岛)变为水(0)。
  • 恢复边界陆地:

    • 将标记为 2 的格子恢复为陆地(1),因为它们与边界相连。

代码:

#include <iostream>
#include <vector>
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] = 2;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);}return;
}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];}}// 步骤一:(将边界陆地1变为2)// 从左边和右边向中间遍历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);}// 步骤二:将地图中的1(孤岛)变为0// 步骤三:将地图中的2(边界陆地)变为1for(int i = 0; i < n; ++i) {for(int j = 0; j < m; ++j) {if(grid[i][j] == 1) grid[i][j] = 0;if(grid[i][j] == 2) grid[i][j] = 1;}}for(int i = 0; i < n; ++i) {for(int j = 0; j < m; ++j) {cout << grid[i][j] << " ";}cout << endl;}
}

103. 水流问题

题目链接:https://kamacoder.com/problempage.php?pid=1175
文章讲解:https://programmercarl.com/kamacoder/0103.水流问题.html
题目状态:看题解

思路:

通过便利在给定的网格中找到能够同时到达两组边界的点。通过深度优先搜索,计算每个点可以访问的区域,并检查这些区域是否满足到达边界的条件。

  1. 变量声明

    • n, m: 网格的行数和列数。
    • dir: 四个方向的移动向量,分别表示上、左、下、右。
  2. 函数 dfs

    • 参数:grid(网格)、visited(记录访问状态的二维布尔数组)、xy(当前坐标)。
    • 功能:从 (x, y) 开始,递归地访问所有可以到达的点。
    • 检查条件:
      • 如果当前点已经访问过,直接返回。
      • 确保下一个点在网格范围内。
      • 确保移动方向的高度不增加(即只能走向相等或更低的高度)。
  3. 函数 isResult

    • 参数:grid(网格)、xy(起始坐标)。
    • 功能:检查从 (x, y) 出发是否可以同时到达第一组和第二组边界。
    • 使用 dfs 标记从 (x, y) 可以到达的所有点。
    • 检查是否可以到达:
      • 第一组边界(上边界和左边界)。
      • 第二组边界(右边界和下边界)。
    • 返回 true 如果可以同时到达两组边界,否则返回 false
  4. main 函数

    • 读取网格的大小 nm
    • 读取网格的高度信息。
    • 遍历每个点 (i, j),调用 isResult 检查是否满足条件。
    • 如果满足条件,输出该点的坐标。

代码:

#include <iostream>
#include <vector>
using namespace std;int n, m;
int dir[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1};// 从x,y出发把可以走的地方都标记上
void dfs(vector<vector<int>> &grid, vector<vector<bool>> &visited, int x, int y) {if(visited[x][y]) 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 >= n || nexty < 0 || nexty >= m) continue;if(grid[x][y] < grid[nextx][nexty]) continue; // 高度不合适dfs(grid, visited, nextx, nexty);}return;
}bool isResult(vector<vector<int>> &grid, int x, int y) {vector<vector<bool>> visited(n, vector<bool>(m, false));// 深搜,将x,y出发能到的节点都标记上dfs(grid, visited, x, y);bool isFirst = false;bool isSecond = false;// 以下就是判断x,y出发,是否到达第一组边界和第二组边界// 第一边界的上边for(int j = 0; j < m; ++j) {if(visited[0][j]) {isFirst = true;break;}}// 第一边界的左边for(int i = 0; i < n; ++i) {if(visited[i][0]) {isFirst = true;break;}}// 第二边界的右边for(int j = 0; j < m; ++j) {if(visited[n - 1][j]) {isSecond = true;break;}}// 第二边界下边for(int i = 0; i < n; ++i) {if(visited[i][m - 1]) {isSecond = true;break;}}if(isFirst && isSecond) return true;return false;
}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];}}// 遍历每一个点,看是否能同时到达第一组边界和第二组边界for(int i = 0; i < n; ++i) {for(int j = 0; j < m; ++j) {if(isResult(grid, i, j)) cout << i << " " << j << endl;}}
}

上述代码和思路在卡码网中运行会出现超时情况,下面是优化的思路和代码。

思路:

不进行单个元素的遍历,而是从边界向中间遍历。

image

image

代码:

#include <iostream>
#include <vector>
using namespace std;
int n, m;
int dir[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1};
void dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y) {if (visited[x][y]) 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 >= n || nexty < 0 || nexty >= m) continue;if (grid[x][y] > grid[nextx][nexty]) continue; // 注意:这里是从低向高遍历dfs (grid, visited, nextx, nexty);}return;
}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>> firstBorder(n, vector<bool>(m, false));// 标记从第一组边界上的节点出发,可以遍历的节点vector<vector<bool>> secondBorder(n, vector<bool>(m, false));// 从最上和最下行的节点出发,向高处遍历for (int i = 0; i < n; i++) {dfs (grid, firstBorder, i, 0); // 遍历最左列,接触第一组边界dfs (grid, secondBorder, i, m - 1); // 遍历最右列,接触第二组边界}// 从最左和最右列的节点出发,向高处遍历for (int j = 0; j < m; j++) {dfs (grid, firstBorder, 0, j); // 遍历最上行,接触第一组边界dfs (grid, secondBorder, n - 1, j); // 遍历最下行,接触第二组边界}for (int i = 0; i < n; i++) {for (int j = 0; j < m; j++) {// 如果这个节点,从第一组边界和第二组边界出发都遍历过,就是结果if (firstBorder[i][j] && secondBorder[i][j]) cout << i << " " << j << endl;;}}
}

104. 建造最大岛屿

题目链接:https://kamacoder.com/problempage.php?pid=1176
文章讲解:https://programmercarl.com/kamacoder/0104.建造最大岛屿.html
题目状态:看题解,好难

思路:

找出通过将一个海水格子变为陆地后,可能形成的最大岛屿面积。通过标记和记录每个岛屿的面积,高效地计算出将某个海水格子变为陆地后的最大可能面积。

  1. 变量声明

    • n, m: 网格的行数和列数。
    • count: 当前岛屿的面积。
    • dir: 四个方向的移动向量,分别表示右、下、左、上。
  2. 函数 dfs

    • 参数:grid(网格)、visited(记录访问状态的二维布尔数组)、xy(当前坐标)、mark(岛屿标记)。
    • 功能:通过深度优先搜索,将所有连接的陆地标记为同一个岛屿。
    • 终止条件:当前点已经访问过或是海水。
    • 标记当前陆地并递归访问相邻的陆地。
  3. main 函数

    • 读取网格的大小 nm
    • 读取网格的高度信息。
    • 初始化 visited 数组和 gridNum 映射,用于存储每个岛屿的面积。
    • 遍历网格,使用 dfs 查找并标记所有岛屿,记录每个岛屿的面积。
    • 检查是否整个网格都是陆地,如果是,直接输出总面积。
  4. 计算最大可能的岛屿面积

    • 遍历每个海水格子 (i, j),尝试将其变为陆地。
    • 对于每个海水格子,检查其四个相邻格子。
    • 计算相邻岛屿的总面积(避免重复计算同一岛屿)。
    • 更新最大岛屿面积。

代码:

#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); // 将与其链接的陆地都标记上 truegridNum[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;}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.hqwc.cn/news/786339.html

如若内容造成侵权/违法违规/事实不符,请联系编程知识网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

carlife

carlife是真的画中画。亿连客户端不是。没去除小房子效果如下:

【专题】2024数智医疗服务时代营销机遇洞察报告合集PDF分享(附原数据表)

原文链接: https://tecdat.cn/?p=37466 如今,人工智能、大数据、物联网等众多智能技术持续且深入地在医药产业中得到应用。这不仅极大地增强了医药产业的创新能力,显著提高了医疗服务的质量与效率,还有力地促进了从预防、诊断、治疗到康复的全链条数字化转型,使市场效率得…

049、Vue3+TypeScript基础,页面通讯之使用mitt在任意组件中通讯

01、main.js代码如下:// 引入createApp用于创建Vue实例 import {createApp} from vue // 引入App.vue根组件 import App from ./App.vue// 引入emitter用于全局事件总线 import emitter from @/utils/emitterconst app = createApp(App);// App.vue的根元素id为app app.mount(…

lua协程实现异步编程模式

异步编程模式只是一个代码结构,c#中的async/await的写法就是异步编程模式,这边就是通过协程来达到和async/await类似的效果。异步编程模式写法1:资源分帧加载 这边运行环境用的是:Unity+xLualua脚本:Assets/Lua/Test9.lua.txtlocal _Time = CS.UnityEngine.Timelocal func…

Echarts可视化大屏框架

效果图展示: 源码:<template><div><!-- Header 部分 --><div class="heads"><h3>大数据可视化分析</h3><span>2023-12-12 12:20:45</span></div><!-- 中间部分 --><div class="middle"&…

可视化表单设计生成器可以实现流程化办公吗?

通过本文可以一起走进低代码技术平台、可视化表单设计生成器的更多优势特点。实现流程化办公一直都是很多客户朋友追求的目标。那么,如何才能实现这一目标?如何为客户提供更优良的产品助力提质、降本、增效?低代码技术平台拥有可视化操作界面、更灵活、更高效、更可靠,是专…

蓝帽杯2020-Misc-签到

蓝帽杯2020-Misc-签到 一、题目 题目名:观色怎么说呢,曲曲折折发现了坑🕳,所以记录下 二、解题 根据自己总结的七大类图片隐写排🕳 1、打开010文件结构查看,本来看着是个jpg,打开是个ps过的gif,未发现附加字符串,foremost没看到其他文件,宽高不涉及修改,IDTA块正常…

Django:Swagger文档的配置

前言 第三方库drf-yasg(Django Rest Swagger)。它是一个为Django Rest Framework提供Swagger/OpenAPI规范支持的库。按照以下步骤进行操作: 安装pip install drf-yasg -i http://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com配置 1、在项目的setting…

REST framework:过滤

一、数据准备 模型类class UserInfo(models.Model):name = models.CharField(max_length=20, verbose_name=用户名)pwd = models.CharField(max_length=18, verbose_name=密码)email = models.EmailField(max_length=40, verbose_name=邮箱)age = models.IntegerField(verbose_…

[消息队列]kafka

Kafka 如何保证消息的消费顺序? 我们在使用消息队列的过程中经常有业务场景需要严格保证消息的消费顺序,比如我们同时发了 2 个消息,这 2 个消息对应的操作分别对应的数据库操作是: 更改用户会员等级。 根据会员等级计算订单价格。 假如这两条消息的消费顺序不一样造成的最…

Miller-Rabin 与 Pollard-Rho

1 Miller-Rabin 算法 1.1 引入 Miller-Rabin 的主要作用就是判断一个较大的数是不是质数。 那么根据基础数论中提到过的试除法,我们知道朴素去判断一个数是否是质数的复杂度是 \(O(\sqrt n)\) 的,在 \(n\ge 10^{18}\) 的时候就十分不优了。 而 Miller-Rabin 则是基于费马小定…

深痛教训 2024.8.23

strlen 这种东西千万不要重复调用多次,不然会 T 飞。 单次复杂度是 \(O(len)\) 的,调用 \(n\) 次直接卡成 \(n^2\) 了。 死亡回放:评测机波动抽象,以上全是同一份代码,死因为 strlen。