Merge branch 'youngyangyang04:master' into master

Author: alanx15a2

problems/0017.电话号码的字母组合.md

@@ -180,7 +180,7 @@ public:
     }
 };
 ```
-* 时间复杂度: O(3^m * 4^n)，其中 m 是对应四个字母的数字个数，n 是对应三个字母的数字个数
+* 时间复杂度: O(3^m * 4^n)，其中 m 是对应三个字母的数字个数，n 是对应四个字母的数字个数
 * 空间复杂度: O(3^m * 4^n)
 
 一些写法，是把回溯的过程放在递归函数里了，例如如下代码，我可以写成这样：（注意注释中不一样的地方）

problems/0684.冗余连接.md

@@ -75,7 +75,7 @@ void join(int u, int v) {
 2. 将两个节点接入到同一个集合，函数：join(int u, int v)，将两个节点连在同一个根节点上
 3. 判断两个节点是否在同一个集合，函数：isSame(int u, int v)，就是判断两个节点是不是同一个根节点
 
-如果还不了解并查集，可以看这里：[并查集理论基础](https://programmercarl.com/图论并查集理论基础.html)
+如果还不了解并查集，可以看这里：[并查集理论基础](https://programmercarl.com/kamacoder/图论并查集理论基础.html)
 
 我们再来看一下这道题目。
 

problems/kamacoder/0106.岛屿的周长.md

@@ -1,6 +1,8 @@
 
 # 106. 岛屿的周长 
 
+[卡码网题目链接（ACM模式）](https://kamacoder.com/problempage.php?pid=1178)
+
 题目描述
 
 给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿是被水包围，并且通过水平方向或垂直方向上相邻的陆地连接而成的。
@@ -108,16 +110,14 @@ int main() {
 
 计算出总的岛屿数量，总的变数为：岛屿数量 * 4
 
-因为有一对相邻两个陆地，边的总数就要减2，如图，有两个陆地相邻，总变数就要减2
+因为有一对相邻两个陆地，边的总数就要减2，如图红线部分，有两个陆地相邻，总边数就要减2
 
 ![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240524120855.png)
 
-
 那么只需要在计算出相邻岛屿的数量就可以了，相邻岛屿数量为cover。
 
 结果 result = 岛屿数量 * 4 - cover * 2;
 
-
 C++代码如下：（详细注释）
 
 ```CPP

problems/kamacoder/0107.寻找存在的路径.md

@@ -0,0 +1,155 @@
+
+# 107. 寻找存在的路径 
+
+[卡码网题目链接（ACM模式）](https://kamacoder.com/problempage.php?pid=1179)
+
+题目描述
+
+给定一个包含 n 个节点的无向图中，节点编号从 1 到 n （含 1 和 n ）。
+
+你的任务是判断是否有一条从节点 source 出发到节点 destination 的路径存在。
+
+输入描述
+
+第一行包含两个正整数 N 和 M，N 代表节点的个数，M 代表边的个数。 
+
+后续 M 行，每行两个正整数 s 和 t，代表从节点 s 与节点 t 之间有一条边。
+
+最后一行包含两个正整数，代表起始节点 source 和目标节点 destination。
+
+输出描述
+
+输出一个整数，代表是否存在从节点 source 到节点 destination 的路径。如果存在，输出 1；否则，输出 0。
+
+输入示例
+
+```
+5 4
+1 2
+1 3
+2 4
+3 4
+1 4
+```
+
+输出示例
+
+1
+
+提示信息
+
+![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240527104432.png)
+
+数据范围：
+
+1 <= M, N <= 100。
+
+## 思路
+
+本题是并查集基础题目。 如果还不了解并查集，可以看这里：[并查集理论基础](https://programmercarl.com/kamacoder/图论并查集理论基础.html)
+
+并查集可以解决什么问题呢？
+
+主要就是集合问题，**两个节点在不在一个集合，也可以将两个节点添加到一个集合中**。
+
+这里整理出我的并查集模板如下：
+
+```CPP
+int n = 1005; // n根据题目中节点数量而定，一般比节点数量大一点就好
+vector<int> father = vector<int> (n, 0); // C++里的一种数组结构
+
+// 并查集初始化
+void init() {
+    for (int i = 0; i < n; ++i) {
+        father[i] = i;
+    }
+}
+// 并查集里寻根的过程
+int find(int u) {
+    return u == father[u] ? u : father[u] = find(father[u]); // 路径压缩
+}
+
+// 判断 u 和 v是否找到同一个根
+bool isSame(int u, int v) {
+    u = find(u);
+    v = find(v);
+    return u == v;
+}
+
+// 将v->u 这条边加入并查集
+void join(int u, int v) {
+    u = find(u); // 寻找u的根
+    v = find(v); // 寻找v的根
+    if (u == v) return ; // 如果发现根相同，则说明在一个集合，不用两个节点相连直接返回
+    father[v] = u;
+}
+```
+
+以上模板中，只要修改 n 大小就可以。
+
+并查集主要有三个功能：
+
+1. 寻找根节点，函数：find(int u)，也就是判断这个节点的祖先节点是哪个
+2. 将两个节点接入到同一个集合，函数：join(int u, int v)，将两个节点连在同一个根节点上
+3. 判断两个节点是否在同一个集合，函数：isSame(int u, int v)，就是判断两个节点是不是同一个根节点
+
+简单介绍并查集之后，我们再来看一下这道题目。
+
+为什么说这道题目是并查集基础题目，题目中各个点是双向图链接，那么判断 一个顶点到另一个顶点有没有有效路径其实就是看这两个顶点是否在同一个集合里。
+
+如何算是同一个集合呢，有边连在一起，就算是一个集合。
+
+此时我们就可以直接套用并查集模板。
+
+使用 join(int u, int v)将每条边加入到并查集。
+
+最后 isSame(int u, int v) 判断是否是同一个根 就可以了。
+
+C++代码如下：
+
+```CPP
+#include <iostream>
+#include <vector>
+using namespace std;
+
+int n; // 节点数量
+vector<int> father = vector<int> (101, 0); // 按照节点大小定义数组大小
+
+// 并查集初始化
+void init() {
+    for (int i = 1; i <= n; i++)  father[i] = i;
+}
+// 并查集里寻根的过程
+int find(int u) {
+    return u == father[u] ? u : father[u] = find(father[u]);
+}
+
+// 判断 u 和 v是否找到同一个根
+bool isSame(int u, int v) {
+    u = find(u);
+    v = find(v);
+    return u == v;
+}
+
+// 将v->u 这条边加入并查集
+void join(int u, int v) {
+    u = find(u); // 寻找u的根
+    v = find(v); // 寻找v的根
+    if (u == v) return ; // 如果发现根相同，则说明在一个集合，不用两个节点相连直接返回
+    father[v] = u;
+}
+
+int main() {
+    int m, s, t, source, destination;
+    cin >> n >> m;
+    init();
+    while (m--) {
+        cin >> s >> t;
+        join(s, t);
+    }
+    cin >> source >> destination;
+    if (isSame(source, destination)) cout << 1 << endl;
+    else cout << 0 << endl;
+}
+```
+

problems/kamacoder/0108.冗余连接.md

@@ -0,0 +1,128 @@
+
+# 108. 冗余连接 
+
+[卡码网题目链接（ACM模式）](https://kamacoder.com/problempage.php?pid=1181)
+
+题目描述
+
+树可以看成是一个图（拥有 n 个节点和 n - 1 条边的连通无环无向图）。
+
+现给定一个拥有 n 个节点（节点编号从 1 到 n）和 n 条边的连通无向图，请找出一条可以删除的边，删除后图可以变成一棵树。
+
+输入描述
+
+第一行包含一个整数 N，表示图的节点个数和边的个数。
+
+后续 N 行，每行包含两个整数 s 和 t，表示图中 s 和 t 之间有一条边。
+
+输出描述
+
+输出一条可以删除的边。如果有多个答案，请删除标准输入中最后出现的那条边。
+
+输入示例
+
+```
+3
+1 2
+2 3
+1 3
+```
+
+输出示例
+
+1 3
+
+提示信息
+
+![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240527110320.png)
+
+图中的 1 2，2 3，1 3 等三条边在删除后都能使原图变为一棵合法的树。但是 1 3 由于是标准输出里最后出现的那条边，所以输出结果为 1 3
+
+数据范围：
+
+1 <= N <= 1000.
+
+## 思路
+
+这道题目也是并查集基础题目。
+
+这里我依然降调一下，并查集可以解决什么问题：两个节点是否在一个集合，也可以将两个节点添加到一个集合中。
+
+如果还不了解并查集，可以看这里：[并查集理论基础](https://programmercarl.com/图论并查集理论基础.html)
+
+我们再来看一下这道题目。
+
+题目说是无向图，返回一条可以删去的边，使得结果图是一个有着N个节点的树（即：只有一个根节点）。
+
+如果有多个答案，则返回二维数组中最后出现的边。
+
+那么我们就可以从前向后遍历每一条边（因为优先让前面的边连上），边的两个节点如果不在同一个集合，就加入集合（即：同一个根节点）。
+
+如图所示： 
+
+![](https://code-thinking-1253855093.file.myqcloud.com/pics/20230604104720.png)
+
+节点A 和节点 B 不在同一个集合，那么就可以将两个 节点连在一起。
+
+如果边的两个节点已经出现在同一个集合里，说明着边的两个节点已经连在一起了，再加入这条边一定就出现环了。
+
+如图所示： 
+
+![](https://code-thinking-1253855093.file.myqcloud.com/pics/20230604104330.png)
+
+已经判断 节点A  和 节点B 在在同一个集合（同一个根），如果将 节点A 和 节点B 连在一起就一定会出现环。 
+
+这个思路清晰之后，代码就很好写了。
+
+并查集C++代码如下：
+
+```CPP
+#include <iostream>
+#include <vector>
+using namespace std;
+int n; // 节点数量
+vector<int> father(1001, 0); // 按照节点大小范围定义数组
+
+// 并查集初始化
+void init() {
+    for (int i = 0; i <= n; ++i) {
+        father[i] = i;
+    }
+}
+// 并查集里寻根的过程
+int find(int u) {
+    return u == father[u] ? u : father[u] = find(father[u]);
+}
+// 判断 u 和 v是否找到同一个根
+bool isSame(int u, int v) {
+    u = find(u);
+    v = find(v);
+    return u == v;
+}
+// 将v->u 这条边加入并查集
+void join(int u, int v) {
+    u = find(u); // 寻找u的根
+    v = find(v); // 寻找v的根
+    if (u == v) return ; // 如果发现根相同，则说明在一个集合，不用两个节点相连直接返回
+    father[v] = u;
+}
+
+int main() {
+    int s, t;
+    cin >> n;
+    init();
+    for (int i = 0; i < n; i++) {
+        cin >> s >> t;
+        if (isSame(s, t)) {
+            cout << s << " " << t << endl;
+            return 0;
+        } else {
+            join(s, t);
+        }
+    }
+}
+```
+
+可以看出，主函数的代码很少，就判断一下边的两个节点在不在同一个集合就可以了。
+
+