代码随想录Day 51|题目：99.岛屿数量、100.岛屿的最大面积

提示：DDU，供自己复习使用。欢迎大家前来讨论~

文章目录

    • 题目一：99. 岛屿数量
    • 思路
      • 深度优先搜索DFS
      • 广度优先搜索BFS
    • 题目二：100. 岛屿的最大面积
      • DFS
      • BFS
    • 总结

题目一：99. 岛屿数量

99. 岛屿数量 (kamacoder.com)

思路

注意题目中每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

也就是说对角线上是不算的， 例如示例二，是三个岛屿，如图：

图一

这道题题目是 DFS，BFS，并查集，基础题目。

本题思路，是用遇到一个没有遍历过的节点陆地，计数器就加一，然后把该节点陆地所能遍历到的陆地都标记上。

在遇到标记过的陆地节点和海洋节点的时候直接跳过。 这样计数器就是最终岛屿的数量。

那么如何把节点陆地所能遍历到的陆地都标记上呢，就可以使用 DFS，BFS或者并查集。

深度优先搜索DFS

思路：

  1. 初始化：创建一个变量result来存储岛屿的数量，初始值为0。
  2. 检查边界条件：如果网格为空或没有行，直接返回0。
  3. 双层循环：使用两个嵌套循环遍历网格的每一行和每一列。
  4. 找到陆地：在内层循环中，检查每个单元格是否为’1’。如果是，增加result的值，并对该单元格进行DFS。
  5. DFS函数：DFS函数将遍历当前单元格的所有四个方向（上、下、左、右），如果相邻单元格是陆地（值为’1’）并且没有越界，则递归调用DFS，并标记该单元格为已访问。
  6. 结束条件：当所有单元格都被检查过，返回result作为最终的岛屿数量。

注意：

  • 递归：DFS是递归实现的，每次递归调用都会检查一个方向的相邻单元格。
  • 边界检查：在DFS中，每次移动前都要检查是否会越界，以避免访问数组之外的内存。
  • 标记已访问：在DFS中，一旦访问了一个陆地单元格，就将其标记为已访问（通常是将’1’改为’0’），以避免重复计数。

下面给出两种版本的代码：

  1. 版本一的写法：
    • 在调用DFS之前，先对节点进行合法性检查。
    • 只有当节点是合法的（即在网格范围内且是陆地）时，才调用DFS函数。
    • 这样做可以减少不必要的递归调用，从而提高效率。
  2. 版本二的写法：
    • 不管节点是否合法，都先调用DFS函数。
    • 在DFS函数内部，通过终止条件来判断节点是否合法。
    • 如果节点不合法（例如，是水或者越界），则直接返回，不进行进一步的递归。
    • 这种写法可能在理解上更直观，因为所有的递归逻辑都封装在DFS函数内部。

两种写法的主要区别在于何时进行合法性检查。版本一在调用DFS之前进行检查，而版本二在DFS函数内部进行检查。理论上，版本一的效率可能更高，因为它避免了对不合法节点的递归调用。然而，从代码的可读性角度来看，版本二可能更清晰，因为它将所有的递归逻辑集中在一起。

完整C++代码如下：

// 版本一 
#include <iostream>
#include <vector>
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) {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);}}
}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) {visited[i][j] = true;result++; // 遇到没访问过的陆地，+1dfs(grid, visited, i, j); // 将与其链接的陆地都标记上 true}}}cout << result << endl;
}

为什么 以上代码中的dfs函数，没有终止条件呢？ 感觉递归没有终止很危险。

其实终止条件 就写在了 调用dfs的地方，如果遇到不合法的方向，直接不会去调用dfs。

当然也可以这么写：

// 版本二
#include <iostream>
#include <vector>
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++; // 遇到没访问过的陆地，+1dfs(grid, visited, i, j); // 将与其链接的陆地都标记上 true}}}cout << result << endl;
}

最后是另一个更清晰简单的思路的C++代码：

#include <vector>
using namespace std;class Solution {
public:int numIslands(vector<vector<char>>& grid) {if (grid.empty() || grid[0].empty()) {return 0;}int result = 0;int row = grid.size();int col = grid[0].size();for (int i = 0; i < row; i++) {for (int j = 0; j < col; j++) {if (grid[i][j] == '1') {result++;dfs(grid, i, j, row, col);}}}return result;}private:void dfs(vector<vector<char>>& grid, int x, int y, int row, int col) {if (x < 0 || y < 0 || x >= row || y >= col || grid[x][y] == '0') {return;}grid[x][y] = '0'; // 标记为已访问dfs(grid, x - 1, y, row, col); // 向上dfs(grid, x + 1, y, row, col); // 向下dfs(grid, x, y - 1, row, col); // 向左dfs(grid, x, y + 1, row, col); // 向右}
};

广度优先搜索BFS

BFS和队列数据结构是相辅相成的

本题完整广搜代码：

#include <iostream>
#include <vector>
#include <queue>
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++; // 遇到没访问过的陆地，+1bfs(grid, visited, i, j); // 将与其链接的陆地都标记上 true}}}cout << result << endl;
}

另一种解法：

#include <vector>
#include <queue>
#include <iostream>
using namespace std;class Solution {
public:int numIslands(vector<vector<char>>& grid) {if (grid.empty() || grid[0].empty()) {return 0;}int result = 0;int row = grid.size();int col = grid[0].size();queue<pair<int, int>> q;for (int i = 0; i < row; i++) {for (int j = 0; j < col; j++) {if (grid[i][j] == '1') {result++;q.push({i, j});grid[i][j] = '0';  // Mark as visitedwhile (!q.empty()) {auto cur = q.front();q.pop();int x = cur.first;int y = cur.second;// Check and mark neighborsif (x - 1 >= 0 && grid[x - 1][y] == '1') {q.push({x - 1, y});grid[x - 1][y] = '0';}if (y - 1 >= 0 && grid[x][y - 1] == '1') {q.push({x, y - 1});grid[x][y - 1] = '0';}if (x + 1 < row && grid[x + 1][y] == '1') {q.push({x + 1, y});grid[x + 1][y] = '0';}if (y + 1 < col && grid[x][y + 1] == '1') {q.push({x, y + 1});grid[x][y + 1] = '0';}}}}}return result;}
};int main() {Solution solution;vector<vector<char>> grid = {{'1', '1', '0', '0', '0'},{'0', '1', '1', '0', '0'},{'0', '0', '0', '1', '1'},{'1', '0', '0', '0', '1'},{'0', '1', '1', '0', '0'}};cout << "Number of islands: " << solution.numIslands(grid) << endl;return 0;
}

题目二：100. 岛屿的最大面积

100. 岛屿的最大面积 (kamacoder.com)

DFS

在编写DFS（深度优先搜索）函数时，存在两种常见写法：一种是在DFS函数外部进行合法性检查后再调用DFS，另一种是在DFS函数内部通过终止条件进行判断。

写法一，dfs只处理下一个节点，即在主函数遇到岛屿就计数为1，dfs处理接下来的相邻陆地

// 版本一
#include <iostream>
#include <vector>
using namespace std;
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);}}
}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) {count = 1;  // 因为dfs处理下一个节点，所以这里遇到陆地了就先计数，dfs处理接下来的相邻陆地visited[i][j] = true;dfs(grid, visited, i, j); // 将与其链接的陆地都标记上 trueresult = max(result, count);}}}cout << result << endl;}

写法二，dfs处理当前节点，即在主函数遇到岛屿就计数为0，dfs处理接下来的全部陆地

dfs

// 版本二
#include <iostream>
#include <vector>
using namespace std;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);}
}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 = vector<vector<bool>>(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) {count = 0; // 因为dfs处理当前节点，所以遇到陆地计数为0，进dfs之后在开始从1计数dfs(grid, visited, i, j); // 将与其链接的陆地都标记上 trueresult = max(result, count);}}}cout << result << endl;
}

两种DFS写法的差异主要在于何时进行岛屿计数：一种是在主函数中遇到新陆地即计数，另一种是将计数完全放在DFS函数内部处理。这种差异导致了不同的代码风格和逻辑结构，也是造成DFS实现方式多样性的根本原因。

BFS

本题BFS代码如下：

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 result = 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); // 将与其链接的陆地都标记上 trueresult = max(result, count);}}}return result;}
};

总结

BFS、DFS、并查集解决岛屿问题

  1. 算法选择：
    • BFS：适用于层级遍历，可以找到最短路径，适合于岛屿问题因为它可以逐层扩展，直到所有相连的陆地都被访问。
    • DFS：适用于深度遍历，可以探索所有可能的路径，适合于岛屿问题因为它可以深入探索每个岛屿直到尽头。
    • 并查集：适用于处理动态连通性问题，通过合并操作来识别和跟踪连通的组件，适合于岛屿问题因为它可以快速判断和合并相连的陆地。
  2. 实现方式：
    • BFS：使用队列存储待访问的节点，逐层访问，每访问一个陆地节点，就将其所有未访问的相邻陆地节点加入队列。
    • DFS：使用递归或栈存储待访问的节点，深入访问，每访问一个陆地节点，就递归地访问其所有未访问的相邻陆地节点。
    • 并查集：使用集合数据结构，每个陆地节点初始时属于自己的集合，当访问到相邻陆地时，通过并查集的合并操作将它们归为同一集合。
  3. 效率和适用性：
    • BFS：在某些情况下可能比DFS更高效，因为它按层次访问，可以更快地找到所有相邻的陆地，但空间复杂度较高。
    • DFS：在递归深度不大的情况下非常高效，但可能会导致栈溢出，特别是在深度很大的网格中。
    • 并查集：在处理大规模数据时通常更高效，因为它减少了重复访问和递归调用，但需要额外的空间来维护集合信息。

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

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

相关文章

linux网络编程4

linux网络编程4

24.9.20学习目录 一.UDP&#xff08;续&#xff09;1.广播广播流程 2.多播多播流程 一.UDP&#xff08;续&#xff09; 1.广播 由一台主机向该主机所在子网内的所有主机发送数据的方式&#xff1b; 广播只能用UDP或原始IP实现&#xff0c;不能使用TCP&#xff1b; 其作用是将…
阅读更多...
ARM驱动学习之9注册字符类设备

ARM驱动学习之9注册字符类设备

ARM驱动学习之9注册字符类设备 • 分配内存空间函数kmalloc – 分配连续的虚拟地址&#xff0c;用于小内存分配。在include/linux/slab.h文件中。 – 参数1&#xff1a;申请的内存大小(最大128K)&#xff0c; – 参数2&#xff1a;GFP_KERNEL&#xff0c;代表优先权&#xff0…
阅读更多...
Tomcat服务器—Windows下载配置详细教程

Tomcat服务器—Windows下载配置详细教程

一、关于 1.1 简介 Tomcat是一个开源的Java Servlet容器和Web服务器&#xff0c;由Apache软件基金会维护。它实现了Java Servlet和JavaServer Pages (JSP) 规范&#xff0c;用于运行Java Web应用程序。Tomcat支持多种Java EE功能&#xff0c;并提供了高效的性能和可扩展性&am…
阅读更多...
光伏电站的方案报告包含哪些内容

光伏电站的方案报告包含哪些内容

光伏电站的方案报告是一个综合性的文档&#xff0c;它详细描述了光伏电站项目的规划、设计、施工、运营及维护等各个环节。一个完整的光伏电站方案报告通常包含以下内容&#xff1a; 一、项目概述 项目背景&#xff1a;介绍光伏电站建设的背景、目的和意义&#xff0c;包括能…
阅读更多...
如何在C++中使用Poppler库读取PDF文件（一）

如何在C++中使用Poppler库读取PDF文件（一）

如果只是读取、渲染pdf文件&#xff0c;除了mupdf以外&#xff0c;在Linux系统中还可以使用Poppler库。Poppler的历史非常古老&#xff0c;X窗口系统中的pdf查看工具xpdf&#xff0c;使用的就是poppler。 Poppler在Linux各发行版&#xff0c;以及BSD族系统之中&#xff0c;都有…
阅读更多...
ARM驱动学习之7 驱动模块传参数

ARM驱动学习之7 驱动模块传参数

ARM驱动学习之7 驱动模块传参数 1.02_DriverModule_01例程的基础上编写简单模块module_param Makefile 文件名字修改为module_param clean部分&#xff1a;rm -rf *.mod.c *.o *.order *.ko *.mod.o *.symvers2.修改module_param.c (1):添加头文件 //定义module_param module…
阅读更多...
Qt Linguist 短语书批量导入翻译.ts导入.qph

Qt Linguist 短语书批量导入翻译.ts导入.qph

文章目录 前言一、准备工作 将ts文件和python文件放到一个根目录下二、执行如下代码 比如这个python文件名字叫test.py三、在根目录下打开powershell之类的控制台&#xff0c;执行python test.py总结 前言 在开发Qt软件过程中&#xff0c;不免需要涉及到翻译软件界面的工作。于…
阅读更多...
华为OD机试 - 分解正整数 - 数学推导（Python/JS/C/C++ 2024 D卷 100分）

华为OD机试 - 分解正整数 - 数学推导（Python/JS/C/C++ 2024 D卷 100分）

华为OD机试 2024E卷题库疯狂收录中&#xff0c;刷题点这里 专栏导读 本专栏收录于《华为OD机试真题&#xff08;Python/JS/C/C&#xff09;》。 刷的越多&#xff0c;抽中的概率越大&#xff0c;私信哪吒&#xff0c;备注华为OD&#xff0c;加入华为OD刷题交流群&#xff0c;…
阅读更多...
线程调优——调整线程池参数提升程序执行效率

线程调优——调整线程池参数提升程序执行效率

先抛出一个问题&#xff0c;程序开发真的是线程越多效率越高吗&#xff1f;多线程是我们程序开发中必不可少的手段&#xff0c;线程就像“孙悟空”开启了分身术一样&#xff0c;每个分身都在“打妖怪”&#xff0c;那是不是分身越多&#xff0c;“打妖怪”的效率就越高&#xf…
阅读更多...
Redisson实现分布式锁（看门狗机制）

Redisson实现分布式锁（看门狗机制）

目录 可重入锁&#xff1a; 锁重试和看门狗机制&#xff1a; 主从一致性&#xff1a; 首先引入依赖&#xff0c;配置好信息 3.使用Redisson的分布式锁 可重入锁&#xff1a; 可重入锁实现是通过redsi中的hash实现的&#xff0c;key依旧是业务名称加id&#xff0c;然后第一个…
阅读更多...
如何成立一家自己的等级保护测评机构？需要哪些条件？有哪些要求？

如何成立一家自己的等级保护测评机构？需要哪些条件？有哪些要求？

给大家的福利&#xff0c;点击下方蓝色字 即可免费领取↓↓↓ &#x1f91f; 基于入门网络安全/黑客打造的&#xff1a;&#x1f449;黑客&网络安全入门&进阶学习资源包 前言 各省、自治区、直辖市公安厅、局网络安全保卫总队&#xff0c;新疆生产建设兵团公安局网络安…
阅读更多...
【高分系列卫星简介——高分一号（GF-1）】

【高分系列卫星简介——高分一号（GF-1）】

高分一号卫星&#xff08;GF-1&#xff09; 高分一号&#xff08;GF-1&#xff09;是中国高分辨率对地观测系统&#xff08;简称“高分专项”&#xff09;的第一颗卫星&#xff0c;具有里程碑式的意义。以下是对高分一号卫星的详细介绍&#xff1a; 一、基本信息 发射时间&…
阅读更多...
2024华为杯研究生数学建模竞赛（研赛）选题建议+初步分析

2024华为杯研究生数学建模竞赛（研赛）选题建议+初步分析

提示&#xff1a;C君认为的难度&#xff1a;DE<C<F&#xff0c;开放度&#xff1a;CDE>F。 华为专项的题目&#xff08;A、B题&#xff09;暂不进行选题分析&#xff0c;不太建议大多数同学选择&#xff0c;对自己专业技能有很大自信的可以选择华为专项的题目。后续会…
阅读更多...
MyBatis-config.xml核心配置

MyBatis-config.xml核心配置

MyBatis-config.xml 包含了会深深影响MyBatis行为的设置和属性信息&#xff0c;配置文档的顶层结构如下 environments&#xff08;环境配置&#xff09; environments用于配置数据库的URL信息&#xff0c;MyBatis-config可以动态配置多个数据源&#xff0c;用于连生产、预发、…
阅读更多...
用 HTML + JavaScript DIY 一个渐进式延迟法定退休年龄测算器

用 HTML + JavaScript DIY 一个渐进式延迟法定退休年龄测算器

为减轻社会和个人因退休年龄变化带来的冲击&#xff0c;近日&#xff0c;全国人民代表大会常务委员会正式发布了关于实施渐进式延迟法定退休年龄的重要决定。 根据该决定&#xff0c;我国将同步启动对男、女职工法定退休年龄的延迟计划。这一调整将采取渐进式的方式进行&#…
阅读更多...
RabbitMQ 高级特性——发送方确认

RabbitMQ 高级特性——发送方确认

文章目录 前言发送方确认confirm 确认模式return 退回模式 常见面试题 前言 前面我们学习了 RabbitMQ 中交换机、队列和消息的持久化&#xff0c;这样能够保证存储在 RabbitMQ Broker 中的交换机和队列中的消息实现持久化&#xff0c;就算 RabbitMQ 服务发生了重启或者是宕机&…
阅读更多...
Nginx实用篇：实现负载均衡、限流与动静分离

Nginx实用篇：实现负载均衡、限流与动静分离

Nginx实用篇&#xff1a;实现负载均衡、限流与动静分离 | 原创作者/编辑&#xff1a;凯哥Java | 分类&#xff1a;Nginx学习系列教程 Nginx 作为一款高性能的 HTTP 服务器及反向代理解决方案&#xff0c;在互联网架构中扮演着至关重要的角色。它…
阅读更多...
C++ 知识要点：变量

C++ 知识要点：变量

一.变量 1. 全局变量与 static 变量&#xff08;作用域、生存周期&#xff09; 全局变量 作用域&#xff1a;全局变量的作用域从它被定义的地方开始&#xff0c;一直到程序结束。在定义它的文件内部以及通过 extern 关键字在其他文件中都可以访问。生存周期&#xff1a;全局…
阅读更多...
TCP 和 UDP 协议的区别？

TCP 和 UDP 协议的区别？

参考TCP 和 UDP的区别_tcp和udp的区别-CSDN博客
阅读更多...
Acwing DFS

Acwing DFS

DFS&#xff1a;深度优先搜索 DFS与BFS的对比 DFS使用栈来实现&#xff0c;BFS使用队列来实现 DFS所需要的空间是 O ( h ) O(h) O(h),而BFS需要的空间是 O ( 2 h ) O(2^h) O(2h),其中h是树的高度&#xff1b; DFS不具有最短路的特性&#xff0c;BFS有最短路的特性 DFS回溯…
阅读更多...
最新文章

Copyright @ 2022~2023