【图论】（一）图论理论基础与岛屿问题

图论理论基础与岛屿问题

  • 图论理论基础
    • 深度搜索（dfs）
    • 广度搜索（bfs）
    • 岛屿问题概述
  • 岛屿数量
    • 岛屿数量-深搜版
    • 岛屿数量-广搜版
  • 岛屿的最大面积
  • 孤岛的总面积
  • 沉没孤岛
  • 建造最大人工岛
  • 水流问题
  • 岛屿的周长

图论理论基础

这里仅对图论相关核心概念做整理总结归纳，具体详细相关概念请参考代码随想录上的整理总结：

  • 图论理论基础
  • 深度优先搜索理论基础
  • 所有可达路径-dfs实战
  • 广度优先搜索理论基础

图的遍历方式基本是两大类：

  • 深度优先搜索（dfs）
  • 广度优先搜索（bfs）

dfs和bfs的区别：

  • dfs是沿一个方向去搜，不到黄河不回头，直到遇到绝境了，搜不下去了，再换方向（换方向的过程就涉及到了回溯），二叉树的前中后序遍历、以及回溯算法就是dfs过程。
  • bfs是先把本节点所连接的所有节点遍历一遍，走到下一个节点的时候，再把连接节点的所有节点遍历一遍，搜索方向更像是广度，四面八方的搜索过程，二叉树的层序遍历就是bfs的过程。

深度搜索（dfs）

  dfs搜索过程是沿着一个方向搜，不到黄河不回头，举个例子，如图是一个无向图，我们要搜索从节点1到节点6的所有路径，那么dfs搜索的第一条路径是这样的（假设第一次延默认方向，就找到了节点6）：

 
此时我们找到了节点6，（遇到黄河了，是不是应该回头了），那么应该再去搜索其他方向了，如下图:

 
路径2撤销了，改变了方向，走路径3（红色线）， 接着也找到终点6。 那么撤销路径2，改为路径3，在dfs中其实就是回溯的过程（这一点很重要)

又找到了一条从节点1到节点6的路径，又到黄河了，此时再回头，下图图四中，路径4撤销（回溯），改为路径5：

 
  又找到了一条从节点1到节点6的路径，又到黄河了，此时再回头，如下图，路径6撤销（回溯的过程），改为路径7，路径8 和 路径7，路径9， 结果发现死路一条，都走到了自己走过的节点：

 
  那么节点2所连接路径和节点3所链接的路径 都走过了，撤销路径只能向上回退，去选择撤销当初节点4的选择，也就是撤销路径5，改为路径10 。 如下图：

 
  上图演示中，其实并没有把 所有的 从节点1 到节点6的dfs（深度优先搜索）的过程都画出来，那样太冗余了，但 已经把dfs 关键的地方都涉及到了，关键就两点：

  • 搜索方向，是认准一个方向搜，直到碰壁之后再换方向
  • 换方向是撤销原路径，改为节点链接的下一个路径，回溯的过程。

代码框架：

vector<vector<int>> result; // 保存符合条件的所有路径
vector<int> path; 			// 起点到终点的路径
void dfs(图，目前搜索的节点)  
{if (终止条件) {存放结果;return;}for (选择：本节点所连接的其他节点) {处理节点;dfs(图，选择的节点); // 递归回溯，撤销处理结果}
}

其实很多dfs写法，没有写终止条件，其实终止条件写在了， 下面dfs递归的逻辑里了，也就是不符合条件，直接不会向下递归

  到这里，对回溯算法会有更深刻的理解，路径2 已经走到了 目的地节点6，那么 路径2 是如何撤销，然后改为 路径3呢？ 其实这就是 回溯的过程，撤销路径2，走换下一个方向

广度搜索（bfs）

  • 广搜的搜索方式就适合于解决两个点之间的最短路径问题。
  • 因为广搜是从起点出发，以起始点为中心一圈一圈进行搜索，一旦遇到终点，记录之前走过的节点就是一条最短路。
  • 当然，也有一些问题是广搜 和 深搜都可以解决的，例如岛屿问题，这类问题的特征就是不涉及具体的遍历方式，只要能把相邻且相同属性的节点标记上就行。

广搜的过程：
  BFS是一圈一圈的搜索过程，我们用一个方格地图，假如每次搜索的方向为 上下左右（不包含斜上方），那么给出一个start起始位置，那么BFS就是从四个方向走出第一步

 
如果加上一个end终止位置，那么使用BFS的搜索过程如图所示：

 
正是因为BFS一圈一圈的遍历方式，所以一旦遇到终止点，那么一定是一条最短路径。

而且地图还可以有障碍，如图所示：

 
代码框架：

  • 其实，我们仅仅需要一个容器，能保存我们要遍历过的元素就可以，那么用队列，还是用栈，甚至用数组，都是可以的。
  • 用队列的话，就是保证每一圈都是一个方向去转，例如统一顺时针或者逆时针。
  • 因为队列是先进先出，加入元素和弹出元素的顺序是没有改变的。
  • 如果用栈的话，就是第一圈顺时针遍历，第二圈逆时针遍历，第三圈有顺时针遍历。
  • 由于各种教程习惯用队列较多，这里我也使用队列来实现，只是记录并不是非要用队列，用栈也可以。

广搜代码模板，该模板针对的就是，上面的四方格的地图：

int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 表示四个方向
// grid 是地图，也就是一个二维数组
// visited标记访问过的节点，不要重复访问
// x,y 表示开始搜索节点的下标
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]) { que.push({nextx, nexty});  		// 队列添加该节点为下一轮要遍历的节点visited[nextx][nexty] = true; 	// 只要加入队列立刻标记，避免重复访问}}}
}

务必理解上述代码，在下述的岛屿问题，解决相邻的问题上也将用到相似的思路与代码。

岛屿问题概述

在图论中，有一类基础问题即是岛屿问题，其中有关岛屿问题的通识描述如下：

  • 给定一个由 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

岛屿数量

卡码网题目链接（ACM模式）

岛屿数量-深搜版

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

程序实现：版本一

#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;return 0;
}
  • 为什么 以上代码中的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) {// 遇到没访问过的陆地，+1result++; 		// 不先标记 直接递归dfs(grid, visited, i, j);	// 将与其链接的陆地都标记上 true}}}cout << result << endl;
}
  • 版本一的写法是 ： 下一个节点是否能合法已经判断完了，传进dfs函数的就是合法节点。
  • 版本二的写法是： 不管节点是否合法，上来就dfs，然后在终止条件的地方进行判断，不合法再 return。
  • 理论上来讲，版本一的效率更高一些，因为避免了 没有意义的递归调用，在调用dfs之前，就做合法性判断。 就个人而言，版本一比版本二逻辑更清晰，更易于个人理解，因此后续都使用版本一的写法。
  • 其实本题是 dfs，bfs 模板题，所以需要注重更多的细节问题，更有利于后面对程序的修改与扩展。

岛屿数量-广搜版

  • 当然本题也是 bfs的一个模板题，也可以使用bfs来解决，即先搜索一个节点周围与其相邻的所有陆地

  • 这里有一个广搜中的重要细节：只要加入队列就代表走过，就需要标记，而不是从队列拿出来的时候再去标记走过。

  • 如果从队列拿出节点，再去标记这个节点走过，就会发生下图所示的结果，会导致很多节点重复加入队列。

 
超时写法 （从队列中取出节点再标记，注意代码注释的地方）

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});while(!que.empty()) {pair<int ,int> cur = que.front(); que.pop();int curx = cur.first;int cury = cur.second;visited[curx][cury] = true; // 从队列中取出在标记走过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});}}}
}

加入队列 就代表走过，立刻标记，正确写法： （注意代码注释的地方）

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; }}}
}

以上两个版本其实，其实只有细微区别，就是 visited[x][y] = true; 放在的地方，这取决于我们对 代码中队列的定义，队列中的节点就表示已经走过的节点。 所以只要加入队列，立即标记该节点走过。

完整广搜代码实现：

#include <iostream>
#include <vector>
#include <queue>using namespace std;int dir[4][2] = {1,0,0,1,-1,0,0,-1};
void bfs(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));vector<vector<bool>> visited(n,vector<bool>(m,false));for(int i = 0; i < n; i++){for(int j = 0; j < m; j++){cin >> grid[i][j];}}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){// 遇到没访问过的陆地，+1result++;// 将与其链接的陆地都标记上 truebfs(grid,visited,i,j);}}}cout << result << endl;return 0;
}

岛屿的最大面积

卡码网题目链接（ACM模式）

  • 本题也是 dfs bfs基础类题目，就是搜索每个岛屿上 1 的数量，然后取一个最大的。
  • 根据上述两种版本的写法，这里 dfs只处理下一个节点，即在主函数遇到岛屿就计数为1，dfs处理接下来的相邻陆地

程序实现(dfs)

#include <iostream>
#include <vector>using namespace std;int area;		//当前面积
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)
{//遍历四周的岛屿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;area++;			//面积 + 1//深度搜索下一个的相连的岛屿dfs(grid,visited,nextx,nexty);}}
}int main()
{int n,m;int result = 0;cin >> n >> m;vector<vector<int>> grid(n,vector<int>(m));vector<vector<bool>> visited(n,vector<bool>(m,false));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(!visited[i][j] && grid[i][j] == 1){visited[i][j] = true;area = 1;dfs(grid,visited,i,j);		//标记相连的陆地为trueresult = max(result,area);	//记录最大的陆地面积}}}cout << result << endl;
}

孤岛的总面积

卡码网：101. 孤岛的总面积

  本题要求找到不靠边的陆地面积，那么我们只要从周边找到陆地然后 通过 dfs或者bfs 将周边靠陆地且相邻的陆地都变成海洋，然后再去重新遍历地图 统计此时还剩下的陆地就可以了。

如图，在遍历地图周围四个边，靠地图四边的陆地，都为绿色

 
在遇到地图周边陆地的时候，将1都变为0，此时地图为这样：

 
然后我们再去遍历这个地图，遇到有陆地的地方，去采用深搜或者广搜，边统计所有陆地。

程序实现（dfs）：

#include <iostream>
#include <vector>using namespace std;// 本题要求找到不靠边的陆地面积，那么我们只要从周边找到陆地然后 通过 dfs或者bfs 
//将周边靠陆地且相邻的陆地都变成海洋，然后再去重新遍历地图 统计此时还剩下的陆地就可以了。// 将相连的岛屿全部变成海洋
int dir[4][2] = {1,0,0,1,-1,0,0,-1};
int cnt = 0;
void dfs(vector<vector<int>>& grid, int x, int y)
{//标记变成海洋grid[x][y] = 0;//用于第二次求孤岛的面积使用 面积++cnt++;// 遍历四周是否有陆地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] == 1)dfs(grid,nextx,nexty);}return;
}int main()
{int n;int 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);}cnt = 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 << cnt << endl;
}

沉没孤岛

卡码网题目链接（ACM模式）

  • 本题和上述孤岛的总面积正好反过来了，上述是求孤岛的面积，而这题是将孤岛的1改为0，那么两题在思路上也是差不多的
  • 思路依然是从地图周边出发，将周边空格相邻的陆地都做上标记（改为2），然后再遍历一遍地图，遇到 陆地 且没做过标记的，那么都是地图中间的 陆地 ，全部改成水域就行。

步骤一： 深搜或者广搜将地图周边的 1 （陆地）全部改成 2 （特殊标记）

步骤二： 将水域中间 1 （陆地）全部改成 水域（0）

步骤三： 将之前标记的 2 改为 1 （陆地）

 
程序实现（dfs）:

#include <iostream>
#include <vector>using namespace std;int dir[4][2] = {1,0,0,1,-1,0,0,-1};
//将靠近地图周边的岛屿全部变成 2
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] == 1)dfs(grid,nextx,nexty);}
}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);}	//	cout << "temp: " << endl;
//	for(int i = 0; i < n;i++)
//	{
//		for(int j = 0; j < m; j++)
//		{
//			cout << grid[i][j] << " ";
//		}		
//		cout << endl;
//	}//步骤二 三 周围陆地变成1 孤岛陆地为0for(int i = 0; i < n; i++){for(int j = 0; j < m; j++){//两个顺序不能换 否则全为0if(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;}
}

建造最大人工岛

卡码网题目链接（ACM模式）

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

案例， 输入陆地与海洋信息如下：

对于上面的案例，有两个位置可将 0 变成 1，使得岛屿的面积最大，即 6。

思路

  • 本题的一个暴力想法，应该是遍历地图尝试 将每一个 0 改成1，然后去搜索地图中的最大的岛屿面积。
  • 计算地图的最大面积：遍历地图 + 深搜岛屿，时间复杂度为 n ∗ n n * n n∗n。
  • 每改变一个0的方格，都需要重新计算一个地图的最大面积，所以 整体时间复杂度为： n 4 n^4 n4

优化思路

  • 其实每次深搜遍历计算最大岛屿面积，我们都做了很多重复的工作，只要用一次深搜把每个岛屿的面积记录下来就好。

第一步： 一次遍历地图，得出各个岛屿的面积，并做编号记录。可以使用map记录，key为岛屿编号，value为岛屿面积

第二步： 再遍历地图，遍历0的方格（因为要将0变成1），并统计该1（由0变成的1）周边岛屿面积，将其相邻面积相加在一起，遍历所有 0 之后，就可以得出 选一个0变成1 之后的最大面积。

拿如下地图的岛屿情况来举例： （1为陆地）

 
第一步： 遍历陆地，并将岛屿到编号和面积上的统计，过程如图所示：

 
统计每一块岛屿的面积，并将岛屿面积存入对应的编号map中保存，核心代码如下：

int area = 0;	// 统计当前遍历岛屿的面积
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, int landIdx)
{// 给陆地标记新标签grid[x][y] = landIdx;//四个方向都会递归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){area++;visited[nextx][nexty] = true;dfs(grid, visited, nextx, nexty, landIdx);}}
}unordered_map<int, int> landArea;
int landIdx = 2;		//标记岛屿的编号
for(int i = 0;i < n; i++)
{for(int j = 0; j < m; j++){//遍历到新的岛屿 计算每个新陆地形成的岛屿面积if(!visited[i][j] && grid[i][j] == 1){area = 1;	// 重新计算一块新的岛屿面积visited[i][j] = true;// 将与其连接的陆地都标记上 true 同时给每个岛屿编个号 landIdxdfs(grid, visited, i, j, landIdx);	landArea[landIdx++] = area;	// 标记每一块编号为 landIdx 的面积为 area}}
}

第二步： 遇到海洋，将0变成1后，看能形成的最大岛屿的面积（遍历海洋周围一圈是否有岛屿），有则拼接岛屿

 
这里要注意几个细节：

  • 特殊情况： n * m 的网格全部为陆地
  • 在海洋周围找到陆地后，拼接岛屿完成后需要对该岛屿进行标记，否则可能重复拼接周围的同一块岛屿

拼接岛屿核心代码如下：

int result = 0;					 // 记录最后结果
unordered_set<int> visitedGrid;  // 标记访问过的岛屿
for(int i = 0; i < n; i++)
{for(int j = 0; j < m; j++){area = 1;				// 记录连接之后的岛屿面积visitedGrid.clear(); 	// 每次使用时，清空//访问到海洋了 //计算这个海洋节点变成陆地后拼接周围四个方向岛屿的面积if(grid[i][j] == 0){for(int k = 0; k < 4; k++){// 计算周围的相邻坐标int nexti = i + dir[k][0];int nextj = j + dir[k][1];//越界if(nexti < 0 || nexti >= grid.size() || nextj < 0 || nextj >= grid[0].size())continue;	// 添加过的岛屿不要重复添加if(visitedGrid.count(grid[nexti][nextj])) continue; //周围遇到新的陆地if(grid[nexti][nextj] > 0){area += landArea[grid[nexti][nextj]];	// 拼接面积visitedGrid.insert(grid[nexti][nextj]); // 标记该岛屿已经添加过}	}//cout << area << endl;result = max(result,area);}}
}

完整代码实现如下：

#include <iostream>
#include <vector>
#include <unordered_map>
#include <unordered_set>using namespace std;int area = 0;	// 统计当前遍历岛屿的面积
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, int landIdx)
{// 给陆地标记新标签grid[x][y] = landIdx;//四个方向都会递归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){area++;visited[nextx][nexty] = true;dfs(grid, visited, nextx, nexty, landIdx);}}
}int main()
{int n, m;cin >> n >> m;int isAllLand = true;		//记录是否全部为陆地vector<vector<int>> grid(n, vector<int>(m));vector<vector<bool>> visited(n, vector<bool>(m, false));for(int i = 0;i < n; i++){for(int j = 0; j < m; j++){cin >>grid[i][j];}}unordered_map<int, int> landArea;int landIdx = 2;				//标记岛屿的编号for(int i = 0;i < n; i++){for(int j = 0; j < m; j++){if(grid[i][j] == 0)isAllLand = false;		//有海洋//遍历到新的岛屿 计算每个新陆地形成的岛屿面积if(!visited[i][j] && grid[i][j] == 1){area = 1;visited[i][j] = true;// 将与其连接的陆地都标记上 true 同时给每个岛屿编个号 landIdxdfs(grid, visited, i, j, landIdx);	landArea[landIdx++] = area;	// 标记每一块编号为 landIdx 的面积为 area}}}// 全是陆地 不用建造了if(isAllLand == true){cout << n * m << endl;return 0;}//	cout << "area: " << endl;
//	for(int i = 2; i < landIdx; i++)
//	{
//		cout << landArea[i] << endl;
//	}
//	
//	cout << "landIdx: " << endl;
//	for(int i = 0; i < n; i++){
//		for(int j = 0; j < m; j++){
//			cout << grid[i][j] << " ";
//		}
//		cout << endl;
//	}
//	int result = 0;					 // 记录最后结果unordered_set<int> visitedGrid;  // 标记访问过的岛屿for(int i = 0; i < n; i++){for(int j = 0; j < m; j++){area = 1;				// 记录连接之后的岛屿面积visitedGrid.clear(); 	// 每次使用时，清空//访问到海洋了 //计算这个海洋节点变成陆地后拼接周围四个方向岛屿的面积if(grid[i][j] == 0){for(int k = 0; k < 4; k++){// 计算周围的相邻坐标int nexti = i + dir[k][0];int nextj = j + dir[k][1];//越界if(nexti < 0 || nexti >= grid.size() || nextj < 0 || nextj >= grid[0].size())continue;	// 添加过的岛屿不要重复添加if(visitedGrid.count(grid[nexti][nextj])) continue; //周围遇到新的陆地if(grid[nexti][nextj] > 0){area += landArea[grid[nexti][nextj]];	// 拼接面积visitedGrid.insert(grid[nexti][nextj]); // 标记该岛屿已经添加过}	}//cout << area << endl;result = max(result,area);}}}cout << result << endl;
}

水流问题

卡码网题目链接（ACM模式）

题目描述：

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

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

输入描述：

  • 第一行包含两个整数 N 和 M，分别表示矩阵的行数和列数。
  • 后续 N 行，每行包含 M 个整数，表示矩阵中的每个单元格的高度。

输出描述：

  输出共有多行，每行输出两个整数，用一个空格隔开，表示可达第一组边界和第二组边界的单元格的坐标，输出顺序任意。

输入示例：

5 5
1 3 1 2 4
1 2 1 3 2
2 4 7 2 1
4 5 6 1 1
1 4 1 2 1

输出示例：

0 4
1 3
2 2
3 0
3 1
3 2
4 0
4 1

提示信息：

  • 图中的蓝色方块上的雨水既能流向第一组边界，也能流向第二组边界。所以最终答案为所有蓝色方块的坐标。

思路

  • 一个比较直白的想法，其实就是 遍历每个点，然后看这个点 能不能同时到达第一组边界和第二组边界。
  • 遍历每一个节点，时间复杂度是 m ∗ n m * n m∗n，遍历每一个节点的时候，都要做深搜，深搜的时间复杂度是： m ∗ n m * n m∗n，那么整体时间复杂度 就是 O ( m 2 ∗ n 2 ) O(m^2 * n^2) O(m2∗n2)，这是一个四次方的时间复杂度，显然时间复杂度超时。
  • 那么我们可以 反过来想，从第一组边界上的节点 逆流而上，将遍历过的节点都标记上。
  • 同样从第二组边界的边上节点 逆流而上，将遍历过的节点也标记上。
  • 然后两方都标记过的节点就是既可以流太平洋也可以流大西洋的节点。

从第一组边界边上节点出发，如图：

 
从第二组边界上节点出发，如图：

#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 >= grid.size() || nexty < 0 || nexty >= grid[0].size())continue;/// 注意：这里是逆向流水if(grid[x][y] <= grid[nextx][nexty])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;}}
}

岛屿的周长

卡码网题目链接（ACM模式）

在矩阵中恰好拥有一个岛屿，假设组成岛屿的陆地边长都为 1，请计算岛屿的周长。岛屿内部没有水域。

输出描述： 输出一个整数，表示岛屿的周长。

输出示例： 14

提示信息：

思路：

  • 岛屿问题最容易让人想到BFS或者DFS，但本题确实还用不上。 为了避免惯性思维，所以这道题。

  • 遍历每一个空格，遇到岛屿则计算其上下左右的空格情况。

  • 如果该陆地上下左右的空格是有水域，则说明是一条边，如图：

  • 如果该陆地上下左右的空格出界了，则说明是一条边，如图：

程序实现：

#include <iostream>
#include <vector>using namespace std;int main()
{int n, m;cin >> n >> m;int dir[4][2] = {1,0,0,1,-1,0,0,-1};	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];}}int res = 0;for(int i = 0; i < n; i++){for(int j = 0; j < m; j++){// 遇到陆地if(grid[i][j] == 1){//计算周围节点坐标for(int k = 0; k < 4; k++){int nexti = i + dir[k][0];int nextj = j + dir[k][1];if(	nexti < 0 || nexti >= n || 	// 越界nextj < 0 || nextj >= m ||	// 越界grid[nexti][nextj] == 0		// 水域){res++;}}}}}cout << res << endl;return 0;
}

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

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

相关文章

java学习--集合（大写五.5）

java学习--集合（大写五.5）

5.collection子接口&#xff1a;Set 5.1Set及其实现类特点 java.util.Collection:存储一个一个的数据 子接口&#xff1a;Set:存储无序的、不可重复的数据(高中学习的集合) 1&#xff09;HashsSet主要实现类 底层使用的是HashMap&#xff0c;即使用数组单向链表红黑树结构进行…
阅读更多...
netron安装（windows linux）

netron安装（windows linux）

目录 netron简介 不同操作系统的安装方式 linux windows mac系统 netron简介 netron可视化工具&#xff0c;是一个可以清晰的看到神经网络模型的每一层的输入输出&#xff0c;网络总体的架构&#xff0c;而且支持各种不同网络框架&#xff0c;简单好用。 效果如下所示 不…
阅读更多...
【视频笔记】408新增知识点信号——里昂视频

【视频笔记】408新增知识点信号——里昂视频

文章目录 **2.信号****3.信号的实现**4.信号的处理**①忽略信号****②执行信号的默认操作****③捕获井处理信号**几个Linux支持的典型信号&#xff1a; **5.信号的产生**① **通过终端按键(键盘)产生信号**例如&#xff0c;CtrlC发送2号信号SIGINT、Ctrl\发送3号信号SIGQUIT② …
阅读更多...
爬虫逆向-js进阶

爬虫逆向-js进阶

1.作用域和闭包 //作用域 // var a 3 // // function test(a){ // var a 1; // console.log(函数内部,a) // } // test(2) // // console.log(a)//闭包 // function jiami(){ // function encrypt(){ // console.log(在这里进行加密了) // } // p…
阅读更多...
五个必备的高清无水印视频素材库推荐

五个必备的高清无水印视频素材库推荐

做抖音、短视频创作的朋友都知道&#xff0c;优质的素材往往决定了作品能否获得更多关注。如果你还不知道在哪里下载高清无水印的视频素材&#xff0c;不用担心&#xff01;今天为你推荐5个高品质的视频素材库&#xff0c;助你轻松创作出爆款视频。 蛙学网 是国内领先的视频素材…
阅读更多...
Mysql常用sql语句与刷题知识点

Mysql常用sql语句与刷题知识点

目录 1. 常用sql2. 刷题知识点 1. 常用sql #查询MySQL中所有的数据库 SHOW DATABASES; #查询当前正在使用的数据库 SELECT DATABASE();#普通创建&#xff08;创建已经存在的数据库会报错&#xff09; CREATE DATABASE 数据库名称; #创建并判断&#xff08;该数据库不存在才创建…
阅读更多...
2.html编辑器介绍

2.html编辑器介绍

html编辑器介绍 HTML 编辑器推荐 理论上我们可以使用记事本进行html编码和开发&#xff0c;但是在实际开发html页面的时候&#xff0c;使用一些专业的开发工具可以使我们更加快速和高效的进行开发&#xff0c;下面介绍几种开发工具&#xff1a; VS Code&#xff1a;https://…
阅读更多...
006_django基于Python的二手房源信息爬取与分析2024_l77153d4

006_django基于Python的二手房源信息爬取与分析2024_l77153d4

目录 系统展示 开发背景 代码实现 项目案例 获取源码 博主介绍&#xff1a;CodeMentor毕业设计领航者、全网关注者30W群落&#xff0c;InfoQ特邀专栏作家、技术博客领航者、InfoQ新星培育计划导师、Web开发领域杰出贡献者&#xff0c;博客领航之星、开发者头条/腾讯云/AW…
阅读更多...
【uniapp】实现触底加载数据

【uniapp】实现触底加载数据

前言&#xff1a;实现界面触底数据加载。后端接口得支持翻页传参&#xff08;本案例使用django&#xff09; 1、后端接口 1.1 封装翻页公共方法standardPagination.py # -*- coding: utf-8 -*- # Time : 2024/10/15 13:15 # Author : super # File : standardPaginat…
阅读更多...
全托自闭症教育，关注孩子每个细节

全托自闭症教育，关注孩子每个细节

原文文章&#xff1a;http://www.zibizhengwang.com/page37.html 自闭症&#xff0c;这一复杂的神经发育障碍&#xff0c;影响着无数孩子的成长与未来。然而&#xff0c;在广州&#xff0c;有一座特别的灯塔——星贝育园自闭症儿童寄宿制学校&#xff0c;它不仅照亮了自闭症儿…
阅读更多...
SpringBoot使用esayExcel根据模板导出excel

SpringBoot使用esayExcel根据模板导出excel

1、依赖 <dependency><groupId>com.alibaba</groupId><artifactId>easyexcel</artifactId><version>3.1.3</version></dependency> 2、模板 3、实体类 package com.skybird.iot.addons.productionManagement.qualityTesting…
阅读更多...
配置MAC地址安全

配置MAC地址安全

概述 MAC地址安全配置是确保网络设备和通信安全的重要措施&#xff0c;通过限制、监控和管理设备的物理地址来防止未授权访问和潜在的网络威胁。以下是对MAC地址安全的概述&#xff1a; 基本概念 定义&#xff1a;MAC地址&#xff08;Media Access Control Address&#xff09…
阅读更多...
Jenkins整合Docker实现CICD自动化部署（若依项目）

Jenkins整合Docker实现CICD自动化部署（若依项目）

前期准备 提前准备好jenkins环境 并且jenkins能使用docker命令&#xff0c;并且已经配置好了jdk、node、maven环境&#xff0c;我之前写了安装jenkins的博客&#xff0c;里面讲得比较详细&#xff0c;推荐用我这种方式安装 docker安装jenkins&#xff0c;并配置jdk、node和m…
阅读更多...
CEP 复杂事件处理引擎进阶：股票中高频 CTA 策略实现与并行回测

CEP 复杂事件处理引擎进阶：股票中高频 CTA 策略实现与并行回测

在 CEP 复杂事件处理引擎入门&#xff1a;初级高频量价因子策略的实现 中&#xff0c;我们详细介绍了 CEP 引擎和它的一些关键概念&#xff0c;如复杂事件和事件监听器等。随后又通过两个初级的 CEP 引擎使用案例介绍了创建并运行一个最简单结构的 CEP 引擎所需的步骤和模块&am…
阅读更多...
骨传导耳机哪个牌子最好？五大高口碑骨传导耳机揭秘！

骨传导耳机哪个牌子最好？五大高口碑骨传导耳机揭秘！

骨传导耳机作为一种创新的音频设备&#xff0c;通过振动头骨直接将声音传递到内耳&#xff0c;不仅为用户提供了全新的听音体验&#xff0c;还能在保持环境音的情况下享受音乐&#xff0c;特别适合户外运动和日常通勤。然而&#xff0c;在众多品牌和型号中选择最适合自己的骨传…
阅读更多...
人工智能正在扼杀云计算的可持续性

人工智能正在扼杀云计算的可持续性

可持续性曾是公共云计算中备受推崇的优势。企业和云提供商大肆宣扬他们的绿色计划&#xff0c;推广采用可再生能源的数据中心&#xff0c;以减少碳足迹。 近几个月来&#xff0c;这个话题已悄然淡出人们的视线。罪魁祸首是什么&#xff1f;对人工智能功能的无限需求正在推动云…
阅读更多...
为何云渲染成为3D设计的首选？效率解析

为何云渲染成为3D设计的首选？效率解析

在3D设计领域&#xff0c;建模和渲染是两个不可或缺的步骤。3D建模软件如3ds Max让设计师能够创造出精美的三维模型&#xff0c;而渲染则是将这些模型转化为逼真图像或动画的过程。 渲染的重要性在于&#xff0c;它能够直观地展示设计的最终效果&#xff0c;使得设计师能够及时…
阅读更多...
MongoDB未授权访问

MongoDB未授权访问

mongodb未授权访问漏洞 复现 MongoDB[//]: # (忙够DB)是一种流行的开源文档数据库管理系统&#xff08;DBMS&#xff09;&#xff0c;基于分布式文件存储的数据库属于NoSQL数据库的一种。 开启MongoDB服务时不添加任何参数时,默认是没有权限验证的 登录的用户可以通过默认端口…
阅读更多...
基于Java微信小程序的高校教务管理系统的详细设计和实现(源码+lw+部署文档+讲解等)

基于Java微信小程序的高校教务管理系统的详细设计和实现(源码+lw+部署文档+讲解等)

详细视频演示 请联系我获取更详细的演示视频 项目运行截图 技术框架 后端采用SpringBoot框架 Spring Boot 是一个用于快速开发基于 Spring 框架的应用程序的开源框架。它采用约定大于配置的理念&#xff0c;提供了一套默认的配置&#xff0c;让开发者可以更专注于业务逻辑而不…
阅读更多...
自动化工具：Ansible

自动化工具：Ansible

目录 一、运维自动化工具有哪些 二、Ansible 概述 1、Ansible 概念 2、Ansible 特点 3、Ansible 工作流程 三、安装部署Ansible 1、环境部署 2、管理节点安装 Ansible 3、查看Ansible相关文件 4、配置主机清单 5、免密管理 ssh-keygen 5.1、测试连通性 5.2、简洁输…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023