From 4fa3e4d9b0a39254aecf4597b3bb916218405e6d Mon Sep 17 00:00:00 2001 From: programmercarl <826123027@qq.com> Date: Sun, 26 May 2024 10:02:54 +0800 Subject: [PATCH] Update --- ...47\344\272\272\345\267\245\345\262\233.md" | 2 +- ...\211\251\350\277\220\350\276\223I-SPFA.md" | 39 +-- ...60\351\207\217\345\271\277\346\220\234.md" | 11 +- ...00\345\244\247\351\235\242\347\247\257.md" | 221 ++++++++++++++ ...04\346\200\273\351\235\242\347\247\257.md" | 180 +++++++++++ ...11\346\262\241\345\255\244\345\262\233.md" | 133 ++++++++ ...64\346\265\201\351\227\256\351\242\230.md" | 279 +++++++++++++++++ ...00\345\244\247\345\262\233\345\261\277.md" | 254 ++++++++++++++++ ...50\345\217\257\350\276\276\346\200\247.md" | 284 ++++++++++++++++++ ...77\347\232\204\345\221\250\351\225\277.md" | 154 ++++++++++ ...72\346\200\273\347\273\223\347\257\207.md" | 29 +- 11 files changed, 1561 insertions(+), 25 deletions(-) create mode 100644 "problems/kamacoder/0100.\345\262\233\345\261\277\347\232\204\346\234\200\345\244\247\351\235\242\347\247\257.md" create mode 100644 "problems/kamacoder/0101.\345\255\244\345\262\233\347\232\204\346\200\273\351\235\242\347\247\257.md" create mode 100644 "problems/kamacoder/0102.\346\262\211\346\262\241\345\255\244\345\262\233.md" create mode 100644 "problems/kamacoder/0103.\346\260\264\346\265\201\351\227\256\351\242\230.md" create mode 100644 "problems/kamacoder/0104.\345\273\272\351\200\240\346\234\200\345\244\247\345\262\233\345\261\277.md" create mode 100644 "problems/kamacoder/0105.\346\234\211\345\220\221\345\233\276\347\232\204\345\256\214\345\205\250\345\217\257\350\276\276\346\200\247.md" create mode 100644 "problems/kamacoder/0106.\345\262\233\345\261\277\347\232\204\345\221\250\351\225\277.md" diff --git "a/problems/0827.\346\234\200\345\244\247\344\272\272\345\267\245\345\262\233.md" "b/problems/0827.\346\234\200\345\244\247\344\272\272\345\267\245\345\262\233.md" index e452e4e395..d24eaacc50 100644 --- "a/problems/0827.\346\234\200\345\244\247\344\272\272\345\267\245\345\262\233.md" +++ "b/problems/0827.\346\234\200\345\244\247\344\272\272\345\267\245\345\262\233.md" @@ -39,7 +39,7 @@ 每改变一个0的方格，都需要重新计算一个地图的最大面积，所以 整体时间复杂度为：n^4。 -如果对深度优先搜索不了解的录友，可以看这里：[深度优先搜索精讲](https://programmercarl.com/图论深搜理论基础.html) +如果对深度优先搜索不了解的录友，可以看这里：[深度优先搜索精讲](https://programmercarl.com/kamacoder/图论深搜理论基础.html) ## 优化思路 diff --git "a/problems/kamacoder/0094.\345\237\216\345\270\202\351\227\264\350\264\247\347\211\251\350\277\220\350\276\223I-SPFA.md" "b/problems/kamacoder/0094.\345\237\216\345\270\202\351\227\264\350\264\247\347\211\251\350\277\220\350\276\223I-SPFA.md" index f41d6fd121..ec35fa9d98 100644 --- "a/problems/kamacoder/0094.\345\237\216\345\270\202\351\227\264\350\264\247\347\211\251\350\277\220\350\276\223I-SPFA.md" +++ "b/problems/kamacoder/0094.\345\237\216\345\270\202\351\227\264\350\264\247\347\211\251\350\277\220\350\276\223I-SPFA.md" @@ -8,11 +8,14 @@ 某国为促进城市间经济交流，决定对货物运输提供补贴。共有 n 个编号为 1 到 n 的城市，通过道路网络连接，网络中的道路仅允许从某个城市单向通行到另一个城市，不能反向通行。 -网络中的道路都有各自的运输成本和政府补贴，道路的权值计算方式为：运输成本 - 政府补贴。权值为正表示扣除了政府补贴后运输货物仍需支付的费用；权值为负则表示政府的补贴超过了支出的运输成本，实际表现为运输过程中还能赚取一定的收益。 +网络中的道路都有各自的运输成本和政府补贴，道路的权值计算方式为：运输成本 - 政府补贴。 +权值为正表示扣除了政府补贴后运输货物仍需支付的费用；权值为负则表示政府的补贴超过了支出的运输成本，实际表现为运输过程中还能赚取一定的收益。 -请找出从城市 1 到城市 n 的所有可能路径中，综合政府补贴后的最低运输成本。如果最低运输成本是一个负数，它表示在遵循最优路径的情况下，运输过程中反而能够实现盈利。 +请找出从城市 1 到城市 n 的所有可能路径中，综合政府补贴后的最低运输成本。 + +如果最低运输成本是一个负数，它表示在遵循最优路径的情况下，运输过程中反而能够实现盈利。 城市 1 到城市 n 之间可能会出现没有路径的情况，同时保证道路网络中不存在任何负权回路。 @@ -41,11 +44,11 @@ 1 3 5 ``` -## 思路 +## 背景 本题我们来系统讲解 Bellman_ford 队列优化算法 ，也叫SPFA算法（Shortest Path Faster Algorithm）。 -> SPFA的称呼来自 1994年西南交通大学段凡丁的论文，其实Bellman_ford 提出后不久 （20世纪50年代末期） 就有队列优化的版本，国际上不承认这个算法是是国内提出的。 所以国际上一般称呼 算法为 Bellman_ford 队列优化算法（Queue improved Bellman-Ford） +> SPFA的称呼来自 1994年西南交通大学段凡丁的论文，其实Bellman_ford 提出后不久 （20世纪50年代末期） 就有队列优化的版本，国际上不承认这个算法是是国内提出的。 所以国际上一般称呼 该算法为 Bellman_ford 队列优化算法（Queue improved Bellman-Ford） 大家知道以上来历，知道 SPFA 和 Bellman_ford 队列优化算法 指的都是一个算法就好。 @@ -72,6 +75,8 @@ 用队列来记录。（其实用栈也行，对元素顺序没有要求） +## 模拟过程 + 接下来来举例这个队列是如何工作的。 以示例给出的所有边为例： @@ -88,19 +93,19 @@ 我们依然使用**minDist数组来表达 起点到各个节点的最短距离**，例如minDist[3] = 5 表示起点到达节点3 的最小距离为5 -初始化，起点为节点1， 起点到起点的最短距离为0，所以minDist[1] 为 0。 将节点1 加入队列 （下次松弛送节点1开始） +初始化，起点为节点1， 起点到起点的最短距离为0，所以minDist[1] 为 0。 将节点1 加入队列 （下次松弛从节点1开始） ![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240411115555.png) ------------ -从队列里取出节点1，松弛节点1 作为出发点链接的边（节点1 -> 节点2）和边（节点1 -> 节点3） +从队列里取出节点1，松弛节点1 作为出发点连接的边（节点1 -> 节点2）和边（节点1 -> 节点3） 边：节点1 -> 节点2，权值为1 ，minDist[2] > minDist[1] + 1 ，更新 minDist[2] = minDist[1] + 1 = 0 + 1 = 1 。 边：节点1 -> 节点3，权值为5 ，minDist[3] > minDist[1] + 5，更新 minDist[3] = minDist[1] + 5 = 0 + 5 = 5。 -将节点2，节点3 加入队列，如图： +将节点2、节点3 加入队列，如图： ![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240411115544.png) @@ -108,7 +113,7 @@ ----------------- -从队列里取出节点2，松弛节点2 作为出发点链接的边（节点2 -> 节点4）和边（节点2 -> 节点5） +从队列里取出节点2，松弛节点2 作为出发点连接的边（节点2 -> 节点4）和边（节点2 -> 节点5） 边：节点2 -> 节点4，权值为1 ，minDist[4] > minDist[2] + (-3) ，更新 minDist[4] = minDist[2] + (-3) = 1 + (-3) = -2 。 @@ -123,7 +128,7 @@ -------------------- -从队列里出去节点3，松弛节点3 作为出发点链接的边。 +从队列里出去节点3，松弛节点3 作为出发点连接的边。 因为没有从节点3作为出发点的边，所以这里就从队列里取出节点3就好，不用做其他操作，如图： @@ -132,11 +137,11 @@ ------------ -从队列中取出节点4，松弛节点4作为出发点链接的边（节点4 -> 节点6） +从队列中取出节点4，松弛节点4作为出发点连接的边（节点4 -> 节点6） 边：节点4 -> 节点6，权值为4 ，minDist[6] > minDist[4] + 4，更新 minDist[6] = minDist[4] + 4 = -2 + 4 = 2 。 -讲节点6加入队列 +将节点6加入队列 如图： @@ -145,7 +150,7 @@ --------------- -从队列中取出节点5，松弛节点5作为出发点链接的边（节点5 -> 节点3），边（节点5 -> 节点6） +从队列中取出节点5，松弛节点5作为出发点连接的边（节点5 -> 节点3），边（节点5 -> 节点6） 边：节点5 -> 节点3，权值为1 ，minDist[3] > minDist[5] + 1 ，更新 minDist[3] = minDist[5] + 1 = 3 + 1 = 4 @@ -157,14 +162,14 @@ -因为节点3，和 节点6 都曾经加入过队列，不用重复加入，避免重复计算。 +因为节点3 和 节点6 都曾经加入过队列，不用重复加入，避免重复计算。 在代码中我们可以用一个数组 visited 来记录入过队列的元素，加入过队列的元素，不再重复入队列。 -------------- -从队列中取出节点6，松弛节点6 作为出发点链接的边。 +从队列中取出节点6，松弛节点6 作为出发点连接的边。 节点6作为终点，没有可以出发的边。 @@ -181,7 +186,7 @@ 了解了大体流程，我们再看代码应该怎么写。 -在上面模拟过程中，我们每次都要知道 一个节点作为出发点 链接了哪些节点。 +在上面模拟过程中，我们每次都要知道 一个节点作为出发点连接了哪些节点。 如果想方便知道这些数据，就需要使用邻接表来存储这个图，如果对于邻接表不了解的话，可以看 [kama0047.参会dijkstra堆](./kama0047.参会dijkstra堆.md) 中 图的存储 部分。 @@ -279,7 +284,7 @@ n为其他数值的时候，也是一样的。 并没有计算 出队列 和 入队列的时间消耗。 因为这个在不同语言上 时间消耗也是不一定的。 -以C++为例，以下两端代码理论上，时间复杂度都是 O(n) ： +以C++为例，以下两段代码理论上，时间复杂度都是 O(n) ： ```CPP for (long long i = 0; i < n; i++) { @@ -316,7 +321,7 @@ SPFA（队列优化版Bellman_ford） 在理论上 时间复杂度更胜一筹 这里可能有录友疑惑，`while (!que.empty())` 队里里 会不会造成死循环？ 例如 图中有环，这样一直有元素加入到队列里？ -其实有环的情况，要看它是 正权回路 还是 负全回路。 +其实有环的情况，要看它是 正权回路 还是 负权回路。 题目描述中，已经说了，本题没有 负权回路 。 diff --git "a/problems/kamacoder/0099.\345\262\233\345\261\277\347\232\204\346\225\260\351\207\217\345\271\277\346\220\234.md" "b/problems/kamacoder/0099.\345\262\233\345\261\277\347\232\204\346\225\260\351\207\217\345\271\277\346\220\234.md" index dfcf062f90..e7a0a8f3ac 100644 --- "a/problems/kamacoder/0099.\345\262\233\345\261\277\347\232\204\346\225\260\351\207\217\345\271\277\346\220\234.md" +++ "b/problems/kamacoder/0099.\345\262\233\345\261\277\347\232\204\346\225\260\351\207\217\345\271\277\346\220\234.md" @@ -54,14 +54,16 @@ 这道题题目是 DFS，BFS，并查集，基础题目。 -本题思路，是用遇到一个没有遍历过的节点陆地，计数器就加一，然后把该节点陆地所能遍历到的陆地都标记上。 +本题思路:遇到一个没有遍历过的节点陆地，计数器就加一，然后把该节点陆地所能遍历到的陆地都标记上。 -在遇到标记过的陆地节点和海洋节点的时候直接跳过。 这样计数器就是最终岛屿的数量。 +再遇到标记过的陆地节点和海洋节点的时候直接跳过。 这样计数器就是最终岛屿的数量。 那么如果把节点陆地所能遍历到的陆地都标记上呢，就可以使用 DFS，BFS或者并查集。 ### 广度优先搜索 +如果不熟悉广搜，建议先看 [广搜理论基础](./图论广搜理论基础.md)。 + 不少同学用广搜做这道题目的时候，超时了。 这里有一个广搜中很重要的细节： 根本原因是**只要 加入队列就代表 走过，就需要标记，而不是从队列拿出来的时候再去标记走过**。 @@ -72,7 +74,7 @@ ![图二](https://code-thinking-1253855093.file.myqcloud.com/pics/20220727100846.png) -超时写法 （从队列中取出节点再标记） +超时写法 （从队列中取出节点再标记，注意代码注释的地方） ```CPP int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向 @@ -98,7 +100,7 @@ void bfs(vector>& grid, vector>& visited, int x, int y ``` -加入队列 就代表走过，立刻标记，正确写法： +加入队列 就代表走过，立刻标记，正确写法： （注意代码注释的地方） ```CPP int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向 @@ -155,7 +157,6 @@ void bfs(const vector>& grid, vector>& visited, int x, } } - int main() { int n, m; cin >> n >> m; diff --git "a/problems/kamacoder/0100.\345\262\233\345\261\277\347\232\204\346\234\200\345\244\247\351\235\242\347\247\257.md" "b/problems/kamacoder/0100.\345\262\233\345\261\277\347\232\204\346\234\200\345\244\247\351\235\242\347\247\257.md" new file mode 100644 index 0000000000..6f8a9ed86a --- /dev/null +++ "b/problems/kamacoder/0100.\345\262\233\345\261\277\347\232\204\346\234\200\345\244\247\351\235\242\347\247\257.md" @@ -0,0 +1,221 @@ + +# 100. 岛屿的最大面积 + +[卡码网题目链接（ACM模式）](https://kamacoder.com/problempage.php?pid=1172) + +[力扣题目链接](https://programmercarl.com/0695.%E5%B2%9B%E5%B1%BF%E7%9A%84%E6%9C%80%E5%A4%A7%E9%9D%A2%E7%A7%AF.html#%E6%80%9D%E8%B7%AF) + +题目描述 + +给定一个由 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 + +提示信息 + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240517103410.png) + +样例输入中，岛屿的最大面积为 4。 + +数据范围： + +* 1 <= M, N <= 50。 + + +## 思路 + +注意题目中每座岛屿只能由**水平方向和/或竖直方向上**相邻的陆地连接形成。 + +也就是说斜角度链接是不算了， 例如示例二，是三个岛屿，如图： + +![图一](https://code-thinking-1253855093.file.myqcloud.com/pics/20220726094200.png) + +这道题目也是 dfs bfs基础类题目，就是搜索每个岛屿上“1”的数量，然后取一个最大的。 + +本题思路上比较简单，难点其实都是 dfs 和 bfs的理论基础，关于理论基础我在这里都有详细讲解 ： + +* [DFS理论基础](https://programmercarl.com/kamacoder/图论深搜理论基础.html) +* [BFS理论基础](https://programmercarl.com/kamacoder/图论广搜理论基础.html) + +### DFS + +很多同学写dfs其实也是凭感觉来的，有的时候dfs函数中写终止条件才能过，有的时候 dfs函数不写终止添加也能过！ + +这里其实涉及到dfs的两种写法。 + +写法一，dfs只处理下一个节点，即在主函数遇到岛屿就计数为1，dfs处理接下来的相邻陆地 + +```CPP +// 版本一 +#include +#include +using namespace std; +int count; +int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向 +void dfs(vector>& grid, vector>& 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> grid(n, vector(m, 0)); + for (int i = 0; i < n; i++) { + for (int j = 0; j < m; j++) { + cin >> grid[i][j]; + } + } + vector> visited(n, vector(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); // 将与其链接的陆地都标记上 true + result = max(result, count); + } + } + } + cout << result << endl; + +} +``` + +写法二，dfs处理当前节点，即在主函数遇到岛屿就计数为0，dfs处理接下来的全部陆地 + +dfs +```CPP +// 版本二 +#include +#include +using namespace std; + +int count; +int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向 +void dfs(vector>& grid, vector>& 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> grid(n, vector(m, 0)); + for (int i = 0; i < n; i++) { + for (int j = 0; j < m; j++) { + cin >> grid[i][j]; + } + } + vector> visited = vector>(n, vector(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); // 将与其链接的陆地都标记上 true + result = max(result, count); + } + } + } + cout << result << endl; +} +``` + +大家通过注释可以发现，两种写法，版本一，在主函数遇到陆地就计数为1，接下来的相邻陆地都在dfs中计算。 + +版本二 在主函数遇到陆地 计数为0，也就是不计数，陆地数量都去dfs里做计算。 + +这也是为什么大家看了很多 dfs的写法 ，发现写法怎么都不一样呢？ 其实这就是根本原因。 + + +### BFS + +关于广度优先搜索，如果大家还不了解的话，看这里：[广度优先搜索精讲](https://programmercarl.com/kamacoder/图论广搜理论基础.html) + +本题BFS代码如下： + +```CPP +class Solution { +private: + int count; + int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向 + void bfs(vector>& grid, vector>& visited, int x, int y) { + queue 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>& grid) { + int n = grid.size(), m = grid[0].size(); + vector> visited = vector>(n, vector(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); // 将与其链接的陆地都标记上 true + result = max(result, count); + } + } + } + return result; + } +}; + +``` + diff --git "a/problems/kamacoder/0101.\345\255\244\345\262\233\347\232\204\346\200\273\351\235\242\347\247\257.md" "b/problems/kamacoder/0101.\345\255\244\345\262\233\347\232\204\346\200\273\351\235\242\347\247\257.md" new file mode 100644 index 0000000000..602fb97738 --- /dev/null +++ "b/problems/kamacoder/0101.\345\255\244\345\262\233\347\232\204\346\200\273\351\235\242\347\247\257.md" @@ -0,0 +1,180 @@ + +# 101. 孤岛的总面积 + +[卡码网题目链接（ACM模式）](https://kamacoder.com/problempage.php?pid=1173) + +题目描述 + +给定一个由 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 + +提示信息： + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240517105557.png) + +在矩阵中心部分的岛屿，因为没有任何一个单元格接触到矩阵边缘，所以该岛屿属于孤岛，总面积为 1。 + + +数据范围： + +1 <= M, N <= 50。 + +## 思路 + +本题使用dfs，bfs，并查集都是可以的。 + +本题要求找到不靠边的陆地面积，那么我们只要从周边找到陆地然后 通过 dfs或者bfs 将周边靠陆地且相邻的陆地都变成海洋，然后再去重新遍历地图 统计此时还剩下的陆地就可以了。 + +如图，在遍历地图周围四个边，靠地图四边的陆地，都为绿色， + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20220830104632.png) + +在遇到地图周边陆地的时候，将1都变为0，此时地图为这样： + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20220830104651.png) + +然后我们再去遍历这个地图，遇到有陆地的地方，去采用深搜或者广搜，边统计所有陆地。 + +如果对深搜或者广搜不够了解，建议先看这里：[深度优先搜索精讲](https://programmercarl.com/kamacoder/图论深搜理论基础.html)，[广度优先搜索精讲](https://programmercarl.com/kamacoder/图论广搜理论基础.html)。 + + +采用深度优先搜索的代码如下： + +```CPP +#include +#include +using namespace std; +int dir[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1}; // 保存四个方向 +int count; // 统计符合题目要求的陆地空格数量 +void dfs(vector>& 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> grid(n, vector(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; +} +``` + +采用广度优先搜索的代码如下： + +```CPP +#include +#include +#include +using namespace std; +int count = 0; +int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向 +void bfs(vector>& grid, int x, int y) { + queue> que; + que.push({x, y}); + grid[x][y] = 0; // 只要加入队列，立刻标记 + count++; + while(!que.empty()) { + pair 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}); + count++; + grid[nextx][nexty] = 0; // 只要加入队列立刻标记 + } + } + } +} + +int main() { + int n, m; + cin >> n >> m; + vector> grid(n, vector(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; +} +``` + diff --git "a/problems/kamacoder/0102.\346\262\211\346\262\241\345\255\244\345\262\233.md" "b/problems/kamacoder/0102.\346\262\211\346\262\241\345\255\244\345\262\233.md" new file mode 100644 index 0000000000..4c7491f716 --- /dev/null +++ "b/problems/kamacoder/0102.\346\262\211\346\262\241\345\255\244\345\262\233.md" @@ -0,0 +1,133 @@ + +# 102. 沉没孤岛 + +[卡码网题目链接（ACM模式）](https://kamacoder.com/problempage.php?pid=1174) + +题目描述： + +给定一个由 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 +``` + +提示信息： + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240517110932.png) + +将孤岛沉没： + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240517110953.png) + +数据范围： + +1 <= M, N <= 50 + +## 思路 + +这道题目和[0101.孤岛的总面积](https://kamacoder.com/problempage.php?pid=1173)正好反过来了，[0101.孤岛的总面积](https://kamacoder.com/problempage.php?pid=1173)是求 地图中间的空格数，而本题是要把地图中间的 1 都改成 0 。 + +那么两题在思路上也是差不多的。 + +思路依然是从地图周边出发，将周边空格相邻的陆地都做上标记，然后在遍历一遍地图，遇到 陆地 且没做过标记的，那么都是地图中间的 陆地 ，全部改成水域就行。 + +有的录友可能想，我在定义一个 visited 二维数组，单独标记周边的陆地，然后遍历地图的时候同时对 数组board 和 数组visited 进行判断，决定 陆地是否变成水域。 + +这样做其实就有点麻烦了，不用额外定义空间了，标记周边的陆地，可以直接改陆地为其他特殊值作为标记。 + +步骤一：深搜或者广搜将地图周边的 1 （陆地）全部改成 2 （特殊标记） + +步骤二：将水域中间 1 （陆地）全部改成 水域（0） + +步骤三：将之前标记的 2 改为 1 （陆地） + +如图： + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240517113813.png) + +整体C++代码如下，以下使用dfs实现，其实遍历方式dfs，bfs都是可以的。 + +```CPP +#include +#include +using namespace std; +int dir[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1}; // 保存四个方向 +void dfs(vector>& 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> grid(n, vector(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] == 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; + } +} +``` diff --git "a/problems/kamacoder/0103.\346\260\264\346\265\201\351\227\256\351\242\230.md" "b/problems/kamacoder/0103.\346\260\264\346\265\201\351\227\256\351\242\230.md" new file mode 100644 index 0000000000..8f99beae1f --- /dev/null +++ "b/problems/kamacoder/0103.\346\260\264\346\265\201\351\227\256\351\242\230.md" @@ -0,0 +1,279 @@ + +# 103. 水流问题 + +[卡码网题目链接（ACM模式）](https://kamacoder.com/problempage.php?pid=1175) + +题目描述： + +现有一个 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 +``` + +提示信息： + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240517115816.png) + +图中的蓝色方块上的雨水既能流向第一组边界，也能流向第二组边界。所以最终答案为所有蓝色方块的坐标。 + + +数据范围： + +1 <= M, N <= 50 + +## 思路 + +一个比较直白的想法，其实就是 遍历每个点，然后看这个点 能不能同时到达第一组边界和第二组边界。 + +至于遍历方式，可以用dfs，也可以用bfs，以下用dfs来举例。 + +那么这种思路的实现代码如下： + +```CPP +#include +#include +using namespace std; +int n, m; +int dir[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1}; + +// 从 x，y 出发 把可以走的地方都标记上 +void dfs(vector>& grid, vector>& 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>& grid, int x, int y) { + vector> visited(n, vector(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> grid(n, vector(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; + } + } + } +} + +``` + +这种思路很直白，但很明显，以上代码超时了。 来看看时间复杂度。 + +遍历每一个节点，是 m * n，遍历每一个节点的时候，都要做深搜，深搜的时间复杂度是： m * n + +那么整体时间复杂度 就是 O(m^2 * n^2) ，这是一个四次方的时间复杂度。 + +## 优化 + +那么我们可以 反过来想，从第一组边界上的节点 逆流而上，将遍历过的节点都标记上。 + +同样从第二组边界的边上节点 逆流而上，将遍历过的节点也标记上。 + +然后**两方都标记过的节点就是既可以流太平洋也可以流大西洋的节点**。 + +从第一组边界边上节点出发，如图： + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240522120036.png) + + +从第二组边界上节点出发，如图： + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240522120122.png) + +按照这样的逻辑，就可以写出如下遍历代码：（详细注释） + + +```CPP +#include +#include +using namespace std; +int n, m; +int dir[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1}; +void dfs(vector>& grid, vector>& 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> grid(n, vector(m, 0)); + + for (int i = 0; i < n; i++) { + for (int j = 0; j < m; j++) { + cin >> grid[i][j]; + } + } + // 标记从第一组边界上的节点出发，可以遍历的节点 + vector> firstBorder(n, vector(m, false)); + + // 标记从第一组边界上的节点出发，可以遍历的节点 + vector> secondBorder(n, vector(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;; + } + } + + +} + +``` + + +时间复杂度分析， 关于dfs函数搜索的过程 时间复杂度是 O(n * m)，这个大家比较容易想。 + +关键看主函数，那么每次dfs的时候，上面还是有for循环的。 + +第一个for循环，时间复杂度是：n * (n * m) 。 + +第二个for循环，时间复杂度是：m * (n * m)。 + +所以本题看起来 时间复杂度好像是 ： n * (n * m) + m * (n * m) = (m * n) * (m + n) 。 + +其实这是一个误区，大家再自己看 dfs函数的实现，其实 有visited函数记录 走过的节点，而走过的节点是不会再走第二次的。 + +所以 调用dfs函数，**只要参数传入的是 数组 firstBorder，那么地图中 每一个节点其实就遍历一次，无论你调用多少次**。 + +同理，调用dfs函数，只要 参数传入的是 数组 secondBorder，地图中每个节点也只会遍历一次。 + +所以，以下这段代码的时间复杂度是 2 * n * m。 地图用每个节点就遍历了两次，参数传入 firstBorder 的时候遍历一次，参数传入 secondBorder 的时候遍历一次。 + +```CPP +// 从最上和最下行的节点出发，向高处遍历 +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); // 遍历最下行，接触第二组边界 +} +``` + +那么本题整体的时间复杂度其实是： 2 * n * m + n * m ，所以最终时间复杂度为 O(n * m) 。 + +空间复杂度为：O(n * m) 这个就不难理解了。开了几个 n * m 的数组。 + + + + diff --git "a/problems/kamacoder/0104.\345\273\272\351\200\240\346\234\200\345\244\247\345\262\233\345\261\277.md" "b/problems/kamacoder/0104.\345\273\272\351\200\240\346\234\200\345\244\247\345\262\233\345\261\277.md" new file mode 100644 index 0000000000..927b20b2d3 --- /dev/null +++ "b/problems/kamacoder/0104.\345\273\272\351\200\240\346\234\200\345\244\247\345\262\233\345\261\277.md" @@ -0,0 +1,254 @@ + +# 104.建造最大岛屿 + +[卡码网题目链接（ACM模式）](https://kamacoder.com/problempage.php?pid=1176) + +题目描述： + +给定一个由 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 +``` + +输出示例 + +6 + +提示信息 + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240522154055.png) + + +对于上面的案例，有两个位置可将 0 变成 1，使得岛屿的面积最大，即 6。 + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240522154110.png) + + +数据范围： + +1 <= M, N <= 50。 + + +## 思路 + +本题的一个暴力想法，应该是遍历地图尝试 将每一个 0 改成1，然后去搜索地图中的最大的岛屿面积。 + +计算地图的最大面积：遍历地图 + 深搜岛屿，时间复杂度为 n * n。 + +（其实使用深搜还是广搜都是可以的，其目的就是遍历岛屿做一个标记，相当于染色，那么使用哪个遍历方式都行，以下我用深搜来讲解） + +每改变一个0的方格，都需要重新计算一个地图的最大面积，所以 整体时间复杂度为：n^4。 + +## 优化思路 + +其实每次深搜遍历计算最大岛屿面积，我们都做了很多重复的工作。 + +只要用一次深搜把每个岛屿的面积记录下来就好。 + +第一步：一次遍历地图，得出各个岛屿的面积，并做编号记录。可以使用map记录，key为岛屿编号，value为岛屿面积 + +第二步：再遍历地图，遍历0的方格（因为要将0变成1），并统计该1（由0变成的1）周边岛屿面积，将其相邻面积相加在一起，遍历所有 0 之后，就可以得出 选一个0变成1 之后的最大面积。 + +拿如下地图的岛屿情况来举例： （1为陆地） + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20220829104834.png) + +第一步，则遍历题目，并将岛屿到编号和面积上的统计，过程如图所示： + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20220829105644.png) + + +本过程代码如下： + +```CPP +int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向 +void dfs(vector>& grid, vector>& 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 >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue; // 越界了，直接跳过 + dfs(grid, visited, nextx, nexty, mark); + } +} + +int largestIsland(vector>& grid) { + int n = grid.size(), m = grid[0].size(); + vector> visited = vector>(n, vector(m, false)); // 标记访问过的点 + unordered_map 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++; // 记录下一个岛屿编号 + } + } + } +} +``` + + +这个过程时间复杂度 n * n 。可能有录友想：分明是两个for循环下面套这一个dfs，时间复杂度怎么回事 n * n呢？ + +其实大家可以仔细看一下代码，**n * n这个方格地图中，每个节点我们就遍历一次，并不会重复遍历**。 + +第二步过程如图所示： + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20220829105249.png) + +也就是遍历每一个0的方格，并统计其相邻岛屿面积，最后取一个最大值。 + +这个过程的时间复杂度也为 n * n。 + +所以整个解法的时间复杂度，为 n * n + n * n 也就是 n^2。 + +当然这里还有一个优化的点，就是 可以不用 visited数组，因为有mark来标记，所以遍历过的grid[i][j]是不等于1的。 + +代码如下： + +```CPP +int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向 +void dfs(vector>& grid, int x, int y, int mark) { + if (grid[x][y] != 1 || grid[x][y] == 0) return; // 终止条件：访问过的节点 或者 遇到海水 + 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, nextx, nexty, mark); + } +} + +int main() { + cin >> n >> m; + vector> grid(n, vector(m, 0)); + + for (int i = 0; i < n; i++) { + for (int j = 0; j < m; j++) { + cin >> grid[i][j]; + } + } + unordered_map 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 (grid[i][j] == 1) { + count = 0; + dfs(grid, i, j, mark); // 将与其链接的陆地都标记上 true + gridNum[mark] = count; // 记录每一个岛屿的面积 + mark++; // 记录下一个岛屿编号 + } + } + } +``` + +不过为了让各个变量各司其事，代码清晰一些，完整代码还是使用visited数组来标记。 + +最后，整体代码如下： + +```CPP +#include +#include +#include +#include +using namespace std; +int n, m; +int count; + +int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向 +void dfs(vector>& grid, vector>& 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> grid(n, vector(m, 0)); + + for (int i = 0; i < n; i++) { + for (int j = 0; j < m; j++) { + cin >> grid[i][j]; + } + } + vector> visited(n, vector(m, false)); // 标记访问过的点 + unordered_map 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 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; + +} +``` + diff --git "a/problems/kamacoder/0105.\346\234\211\345\220\221\345\233\276\347\232\204\345\256\214\345\205\250\345\217\257\350\276\276\346\200\247.md" "b/problems/kamacoder/0105.\346\234\211\345\220\221\345\233\276\347\232\204\345\256\214\345\205\250\345\217\257\350\276\276\346\200\247.md" new file mode 100644 index 0000000000..81f4f6f0ac --- /dev/null +++ "b/problems/kamacoder/0105.\346\234\211\345\220\221\345\233\276\347\232\204\345\256\214\345\205\250\345\217\257\350\276\276\346\200\247.md" @@ -0,0 +1,284 @@ + +# 105.有向图的完全可达性 + +[卡码网题目链接（ACM模式）](https://kamacoder.com/problempage.php?pid=1177) + +【题目描述】 + +给定一个有向图，包含 N 个节点，节点编号分别为 1，2，...，N。现从 1 号节点开始，如果可以从 1 号节点的边可以到达任何节点，则输出 1，否则输出 -1。 + +【输入描述】 + +第一行包含两个正整数，表示节点数量 N 和边的数量 K。 后续 K 行，每行两个正整数 s 和 t，表示从 s 节点有一条边单向连接到 t 节点。 + +【输出描述】 + +如果可以从 1 号节点的边可以到达任何节点，则输出 1，否则输出 -1。 + +【输入示例】 + +``` +4 4 +1 2 +2 1 +1 3 +3 4 +``` + +【输出示例】 + +1 + +【提示信息】 + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240522174707.png) + +从 1 号节点可以到达任意节点，输出 1。 + +数据范围： + +* 1 <= N <= 100； +* 1 <= K <= 2000。 + +## 思路 + +本题给我们是一个有向图， 意识到这是有向图很重要！ + +接下来我们再画一个图，从图里可以直观看出来，节点6 是 不能到达节点1 的 + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240522175451.png) + +这就很容易让我们想起岛屿问题，只要发现独立的岛，就是不可到达的。 + +**但本题是有向图**，在有向图中，即使所有节点都是链接的，但依然不可能从0出发遍历所有边。 + +例如上图中，节点1 可以到达节点2，但节点2是不能到达节点1的。 + +所以本题是一个**有向图搜索全路径的问题**。 只能用深搜（DFS）或者广搜（BFS）来搜。 + +**以下dfs分析 大家一定要仔细看，本题有两种dfs的解法，很多题解没有讲清楚**。 看完之后 相信你对dfs会有更深的理解。 + +深搜三部曲： + +1. 确认递归函数，参数 + +需要传入地图，需要知道当前我们拿到的key，以至于去下一个房间。 + +同时还需要一个数组，用来记录我们都走过了哪些房间，这样好知道最后有没有把所有房间都遍历的，可以定义一个一维数组。 + +所以 递归函数参数如下： + +```C++ +// key 当前得到的可以 +// visited 记录访问过的房间 +void dfs(const vector>& graph, int key, vector& visited) { +``` + +2. 确认终止条件 + +遍历的时候，什么时候终止呢？ + +这里有一个很重要的逻辑，就是在递归中，**我们是处理当前访问的节点，还是处理下一个要访问的节点**。 + +这决定 终止条件怎么写。 + +首先明确，本题中什么叫做处理，就是 visited数组来记录访问过的节点，该节点默认 数组里元素都是false，把元素标记为true就是处理 本节点了。 + +如果我们是处理当前访问的节点，当前访问的节点如果是 true ，说明是访问过的节点，那就终止本层递归，如果不是true，我们就把它赋值为true，因为这是我们处理本层递归的节点。 + +代码就是这样： + +```C++ +// 写法一：处理当前访问的节点 +void dfs(const vector>& graph, int key, vector& visited) { + if (visited[key]) { + return; + } + visited[key] = true; + list keys = graph[key]; + for (int key : keys) { + // 深度优先搜索遍历 + dfs(graph, key, visited); + } +} +``` + +如果我们是处理下一层访问的节点，而不是当前层。那么就要在 深搜三部曲中第三步：处理目前搜索节点出发的路径的时候对 节点进行处理。 + +这样的话，就不需要终止条件，而是在 搜索下一个节点的时候，直接判断 下一个节点是否是我们要搜的节点。 + +代码就是这样的： + +```C++ +// 写法二：处理下一个要访问的节点 +void dfs(const vector>& graph, int key, vector& visited) { + list keys = rooms[key]; + for (int key : keys) { + if (visited[key] == false) { // 确认下一个是没访问过的节点 + visited[key] = true; + dfs(rooms, key, visited); + } + } +} +``` + +可以看出，**如何看待 我们要访问的节点，直接决定了两种不一样的写法**，很多录友对这一块很模糊，可能做过这道题，但没有思考到这个维度上。 + + +3. 处理目前搜索节点出发的路径 + +其实在上面，深搜三部曲 第二部，就已经讲了，因为终止条件的两种写法， 直接决定了两种不一样的递归写法。 + +这里还有细节： + +看上面两个版本的写法中， 好像没有发现回溯的逻辑。 + +我们都知道，有递归就有回溯，回溯就在递归函数的下面， 那么之前我们做的dfs题目，都需要回溯操作，例如：[0098.所有可达路径](./0098.所有可达路径)， **为什么本题就没有回溯呢？** + +代码中可以看到dfs函数下面并没有回溯的操作。 + +此时就要在思考本题的要求了，本题是需要判断 1节点 是否能到所有节点，那么我们就没有必要回溯去撤销操作了，只要遍历过的节点一律都标记上。 + +**那什么时候需要回溯操作呢？** + +当我们需要搜索一条可行路径的时候，就需要回溯操作了，因为没有回溯，就没法“调头”， 如果不理解的话，去看我写的 [0098.所有可达路径](./0098.所有可达路径.md) 的题解。 + + +以上分析完毕，DFS整体实现C++代码如下： + +```CPP +// 写法一：dfs 处理当前访问的节点 +#include +#include +#include +using namespace std; + +void dfs(const vector>& graph, int key, vector& visited) { + if (visited[key]) { + return; + } + visited[key] = true; + list keys = graph[key]; + for (int key : keys) { + // 深度优先搜索遍历 + dfs(graph, key, visited); + } +} + +int main() { + int n, m, s, t; + cin >> n >> m; + + // 节点编号从1到n，所以申请 n+1 这么大的数组 + vector> graph(n + 1); // 邻接表 + while (m--) { + cin >> s >> t; + // 使用邻接表 ，表示 s -> t 是相连的 + graph[s].push_back(t); + } + vector visited(n + 1, false); + dfs(graph, 1, visited); + //检查是否都访问到了 + for (int i = 1; i <= n; i++) { + if (visited[i] == false) { + cout << -1 << endl; + return 0; + } + } + cout << 1 << endl; +} + +``` + +**第二种写法注意有注释的地方是和写法一的区别** + +```c++ +写法二：dfs处理下一个要访问的节点 +#include +#include +#include +using namespace std; + +void dfs(const vector>& graph, int key, vector& visited) { + list keys = rooms[key]; + for (int key : keys) { + if (visited[key] == false) { // 确认下一个是没访问过的节点 + visited[key] = true; + dfs(rooms, key, visited); + } + } +} + +int main() { + int n, m, s, t; + cin >> n >> m; + + vector> graph(n + 1); + while (m--) { + cin >> s >> t; + graph[s].push_back(t); + + } + vector visited(n + 1, false); + + visited[0] = true; // 节点1 预先处理 + dfs(graph, 1, visited); + + for (int i = 1; i <= n; i++) { + if (visited[i] == false) { + cout << -1 << endl; + return 0; + } + } + cout << 1 << endl; +} + +``` + +本题我也给出 BFS C++代码，[BFS理论基础](https://programmercarl.com/kamacoder/%E5%9B%BE%E8%AE%BA%E6%B7%B1%E6%90%9C%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html)，代码如下： + +```CPP +#include +#include +#include +#include +using namespace std; + +int main() { + int n, m, s, t; + cin >> n >> m; + + vector> graph(n + 1); + while (m--) { + cin >> s >> t; + graph[s].push_back(t); + + } + vector visited(n + 1, false); + visited[1] = true; // 1 号房间开始 + queue que; + que.push(1); // 1 号房间开始 + + // 广度优先搜索的过程 + while (!que.empty()) { + int key = que.front(); que.pop(); + list keys = graph[key]; + for (int key : keys) { + if (!visited[key]) { + que.push(key); + visited[key] = true; + } + } + } + + for (int i = 1; i <= n; i++) { + if (visited[i] == false) { + cout << -1 << endl; + return 0; + } + } + cout << 1 << endl; +} + +``` + diff --git "a/problems/kamacoder/0106.\345\262\233\345\261\277\347\232\204\345\221\250\351\225\277.md" "b/problems/kamacoder/0106.\345\262\233\345\261\277\347\232\204\345\221\250\351\225\277.md" new file mode 100644 index 0000000000..4a81922d43 --- /dev/null +++ "b/problems/kamacoder/0106.\345\262\233\345\261\277\347\232\204\345\221\250\351\225\277.md" @@ -0,0 +1,154 @@ + +# 106. 岛屿的周长 + +题目描述 + +给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿是被水包围，并且通过水平方向或垂直方向上相邻的陆地连接而成的。 + + +你可以假设矩阵外均被水包围。在矩阵中恰好拥有一个岛屿，假设组成岛屿的陆地边长都为 1，请计算岛屿的周长。岛屿内部没有水域。 + +输入描述 + +第一行包含两个整数 N, M，表示矩阵的行数和列数。之后 N 行，每行包含 M 个数字，数字为 1 或者 0，表示岛屿的单元格。 + +输出描述 + +输出一个整数，表示岛屿的周长。 + +输入示例 + +``` +5 5 +0 0 0 0 0 +0 1 0 1 0 +0 1 1 1 0 +0 1 1 1 0 +0 0 0 0 0 +``` + +输出示例 + +14 + +提示信息 + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240524115244.png) + +岛屿的周长为 14。 + +数据范围： + +1 <= M, N <= 50。 + +## 思路 + +岛屿问题最容易让人想到BFS或者DFS，但本题确实还用不上。 + +为了避免大家惯性思维，所以给大家安排了这道题目。 + +### 解法一： + +遍历每一个空格，遇到岛屿则计算其上下左右的空格情况。 + +如果该陆地上下左右的空格是有水域，则说明是一条边，如图： + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240524115933.png) + +陆地的右边空格是水域，则说明找到一条边。 + + +如果该陆地上下左右的空格出界了，则说明是一条边，如图： + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240524120105.png) + +该录友的下边空格出界了，则说明找到一条边。 + + +C++代码如下：（详细注释） + +```CPP +#include +#include +using namespace std; +int main() { + int n, m; + cin >> n >> m; + vector> grid(n, vector(m, 0)); + for (int i = 0; i < n; i++) { + for (int j = 0; j < m; j++) { + cin >> grid[i][j]; + } + } + int direction[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; + int result = 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 x = i + direction[k][0]; + int y = j + direction[k][1]; // 计算周边坐标x,y + if (x < 0 // x在边界上 + || x >= grid.size() // x在边界上 + || y < 0 // y在边界上 + || y >= grid[0].size() // y在边界上 + || grid[x][y] == 0) { // x,y位置是水域 + result++; + } + } + } + } + } + cout << result << endl; + +} +``` + +### 解法二： + +计算出总的岛屿数量，总的变数为：岛屿数量 * 4 + +因为有一对相邻两个陆地，边的总数就要减2，如图，有两个陆地相邻，总变数就要减2 + +![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240524120855.png) + + +那么只需要在计算出相邻岛屿的数量就可以了，相邻岛屿数量为cover。 + +结果 result = 岛屿数量 * 4 - cover * 2; + + +C++代码如下：（详细注释） + +```CPP +#include +#include +using namespace std; +int main() { + int n, m; + cin >> n >> m; + vector> grid(n, vector(m, 0)); + for (int i = 0; i < n; i++) { + for (int j = 0; j < m; j++) { + cin >> grid[i][j]; + } + } + int sum = 0; // 陆地数量 + int cover = 0; // 相邻数量 + for (int i = 0; i < n; i++) { + for (int j = 0; j < m; j++) { + if (grid[i][j] == 1) { + sum++; // 统计总的陆地数量 + // 统计上边相邻陆地 + if(i - 1 >= 0 && grid[i - 1][j] == 1) cover++; + // 统计左边相邻陆地 + if(j - 1 >= 0 && grid[i][j - 1] == 1) cover++; + // 为什么没统计下边和右边？ 因为避免重复计算 + } + } + } + + cout << sum * 4 - cover * 2 << endl; + +} +``` diff --git "a/problems/kamacoder/\345\233\276\350\256\272\346\200\273\347\273\223\347\257\207.md" "b/problems/kamacoder/\345\233\276\350\256\272\346\200\273\347\273\223\347\257\207.md" index 92b3581d53..65816bb1ec 100644 --- "a/problems/kamacoder/\345\233\276\350\256\272\346\200\273\347\273\223\347\257\207.md" +++ "b/problems/kamacoder/\345\233\276\350\256\272\346\200\273\347\273\223\347\257\207.md" @@ -5,6 +5,12 @@ 至此算上本篇，一共30篇文章，图论之旅就在此收官了。 +在[0098.所有可达路径](./0098.所有可达路径.md) ，我们接触了两种图的存储方式，邻接表和邻接矩阵，数量掌握两种图的存储方式很重要。 + +这也是大家习惯在核心代码模式下刷题 经常忽略的 知识点。因为在力扣上刷题不需要掌握图的存储方式。 + + + ## 深搜与广搜 @@ -14,11 +20,30 @@ * 代码模板：需要熟练掌握深搜和广搜的基本写法。 * 应用场景：图论题目基本上可以即用深搜也可以广搜，无疑是用哪个方便而已 -深搜注意事项 同样是深搜模板题，会有两种写法， -广搜注意事项 + +在[0099.岛屿的数量深搜.md](./0099.岛屿的数量深搜.md) 和 [0105.有向图的完全可达性](./0105.有向图的完全可达性.md)，涉及到dfs的两种写法。 + +我们对dfs函数的定义是 是处理当前节点 还是处理下一个节点 很重要，决定了两种dfs的写法。 + +这也是为什么很多录友看到不同的dfs写法，结果发现提交都能过的原因。 + +而深搜还有细节，有的深搜题目需要回溯，有的就不用回溯， + +需要计算路径的问题，一般需要回溯，如果只是染色问题 就不需要回溯。 + +例如： [0105.有向图的完全可达性](./0105.有向图的完全可达性.md) 深搜就不需要回溯，而 [0098.所有可达路径](./0098.所有可达路径.md) 中的递归就需要回溯，文章中都有详细讲解 + + + +注意：以上说的是不需要回溯，不是没有回溯，只要有递归就会有回溯，只是我们是否需要用到回溯这个过程 才是要考虑的 + + +广搜注意事项，很多录友写广搜超时了。 + +深搜和广搜是图论的基础，也有很多变形，我在图论里用最大岛屿问题，讲了很多 ## 并查集