feat: add solutions to lc problem: No.1135.Connecting Cities With Minimum Cost

Author: yanglbme

solution/1100-1199/1135.Connecting Cities With Minimum Cost/README.md

@@ -46,27 +46,233 @@
 	<li><code>conections[i][0] != conections[i][1]</code></li>
 </ol>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
+最小生成树 + 并查集。
+
+并查集模板：
+
+模板 1——朴素并查集：
+
+```python
+# 初始化，p存储每个点的父节点
+p = list(range(n))
+
+# 返回x的祖宗节点
+def find(x):
+    if p[x] != x:
+        # 路径压缩
+        p[x] = find(p[x])
+    return p[x]
+
+# 合并a和b所在的两个集合
+p[find(a)] = find(b)
+```
+
+模板 2——维护 size 的并查集：
+
+```python
+# 初始化，p存储每个点的父节点，size只有当节点是祖宗节点时才有意义，表示祖宗节点所在集合中，点的数量
+p = list(range(n))
+size = [1] * n
+
+# 返回x的祖宗节点
+def find(x):
+    if p[x] != x:
+        # 路径压缩
+        p[x] = find(p[x])
+    return p[x]
+
+# 合并a和b所在的两个集合
+if find(a) != find(b):
+    size[find(b)] += size[find(a)]
+    p[find(a)] = find(b)
+```
+
+模板 3——维护到祖宗节点距离的并查集：
+
+```python
+# 初始化，p存储每个点的父节点，d[x]存储x到p[x]的距离
+p = list(range(n))
+d = [0] * n
+
+# 返回x的祖宗节点
+def find(x):
+    if p[x] != x:
+        t = find(p[x])
+        d[x] += d[p[x]]
+        p[x] = t
+    return p[x]
+
+# 合并a和b所在的两个集合
+p[find(a)] = find(b)
+d[find(a)] = distance
+```
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def minimumCost(self, n: int, connections: List[List[int]]) -> int:
+        p = list(range(n))
+        connections.sort(key=lambda x: x[2])
+        res = 0
+
+        def find(x):
+            if p[x] != x:
+                p[x] = find(p[x])
+            return p[x]
+
+        def union(a, b):
+            pa, pb = find(a - 1), find(b - 1)
+            if pa == pb:
+                return False
+            p[pa] = pb
+            return True
+
+        for c1, c2, cost in connections:
+            if union(c1, c2):
+                n -= 1
+                res += cost
+                if n == 1:
+                    return res
+        return -1
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    private int[] p;
+
+    public int minimumCost(int n, int[][] connections) {
+        p = new int[n];
+        for (int i = 0; i < n; ++i) {
+            p[i] = i;
+        }
+        Arrays.sort(connections, (a, b) -> a[2] - b[2]);
+        int res = 0;
+        for (int[] e : connections) {
+            if (union(e[0], e[1])) {
+                res += e[2];
+                --n;
+                if (n == 1) {
+                    return res;
+                }
+            }
+        }
+        return -1;
+    }
+
+    private int find(int x) {
+        if (p[x] != x) {
+            p[x] = find(p[x]);
+        }
+        return p[x];
+    }
+
+    private boolean union(int a, int b) {
+        int pa = find(a - 1), pb = find(b - 1);
+        if (pa == pb) {
+            return false;
+        }
+        p[pa] = pb;
+        return true;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> p;
+
+    int minimumCost(int n, vector<vector<int>> &connections) {
+        p.resize(n);
+        for (int i = 0; i < n; ++i) p[i] = i;
+        auto cmp = [](auto &a, auto &b)
+        {
+            return a[2] < b[2];
+        };
+        sort(connections.begin(), connections.end(), cmp);
+        int res = 0;
+        for (auto e : connections)
+        {
+            if (unite(e[0], e[1]))
+            {
+                res += e[2];
+                --n;
+                if (n == 1) return res;
+            }
+        }
+        return -1;
+    }
+
+    int find(int x) {
+        if (p[x] != x) p[x] = find(p[x]);
+        return p[x];
+    }
+
+    bool unite(int a, int b) {
+        int pa = find(a - 1), pb = find(b - 1);
+        if (pa == pb) return false;
+        p[pa] = pb;
+        return true;
+    }
+};
+```
 
+### **Go**
+
+```go
+var p []int
+
+func minimumCost(n int, connections [][]int) int {
+	p = make([]int, n)
+	for i := 0; i < len(p); i++ {
+		p[i] = i
+	}
+	sort.Slice(connections, func(i, j int) bool {
+		return connections[i][2] < connections[j][2]
+	})
+	res := 0
+	for _, e := range connections {
+		if union(e[0], e[1]) {
+			res += e[2]
+			n--
+			if n == 1 {
+				return res
+			}
+		}
+	}
+	return -1
+}
+
+func find(x int) int {
+	if p[x] != x {
+		p[x] = find(p[x])
+	}
+	return p[x]
+}
+
+func union(a, b int) bool {
+	pa, pb := find(a-1), find(b-1)
+	if pa == pb {
+		return false
+	}
+	p[pa] = pb
+	return true
+}
 ```
 
 ### **...**