Update

problems/kamacoder/0053.寻宝-Kruskal.md

@@ -404,8 +404,145 @@ Kruskal算法 时间复杂度 为 nlogn，其中n 为边的数量，适用稀疏
 
 ### Java 
 
+```Java 
+import java.util.*;
+
+class Edge {
+    int l, r, val;
+
+    Edge(int l, int r, int val) {
+        this.l = l;
+        this.r = r;
+        this.val = val;
+    }
+}
+
+public class Main {
+    private static int n = 10001;
+    private static int[] father = new int[n];
+
+    // 并查集初始化
+    public static void init() {
+        for (int i = 0; i < n; i++) {
+            father[i] = i;
+        }
+    }
+
+    // 并查集的查找操作
+    public static int find(int u) {
+        if (u == father[u]) return u;
+        return father[u] = find(father[u]);
+    }
+
+    // 并查集的加入集合
+    public static void join(int u, int v) {
+        u = find(u);
+        v = find(v);
+        if (u == v) return;
+        father[v] = u;
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int v = scanner.nextInt();
+        int e = scanner.nextInt();
+        List<Edge> edges = new ArrayList<>();
+        int result_val = 0;
+
+        for (int i = 0; i < e; i++) {
+            int v1 = scanner.nextInt();
+            int v2 = scanner.nextInt();
+            int val = scanner.nextInt();
+            edges.add(new Edge(v1, v2, val));
+        }
+
+        // 执行Kruskal算法
+        edges.sort(Comparator.comparingInt(edge -> edge.val));
+
+        // 并查集初始化
+        init();
+
+        // 从头开始遍历边
+        for (Edge edge : edges) {
+            int x = find(edge.l);
+            int y = find(edge.r);
+
+            if (x != y) {
+                result_val += edge.val;
+                join(x, y);
+            }
+        }
+        System.out.println(result_val);
+        scanner.close();
+    }
+}
+ 
+```
+
 ### Python
 
+```python 
+class Edge:
+    def __init__(self, l, r, val):
+        self.l = l
+        self.r = r
+        self.val = val
+
+n = 10001
+father = list(range(n))
+
+def init():
+    global father
+    father = list(range(n))
+
+def find(u):
+    if u != father[u]:
+        father[u] = find(father[u])
+    return father[u]
+
+def join(u, v):
+    u = find(u)
+    v = find(v)
+    if u != v:
+        father[v] = u
+
+def kruskal(v, edges):
+    edges.sort(key=lambda edge: edge.val)
+    init()
+    result_val = 0
+
+    for edge in edges:
+        x = find(edge.l)
+        y = find(edge.r)
+        if x != y:
+            result_val += edge.val
+            join(x, y)
+
+    return result_val
+
+if __name__ == "__main__":
+    import sys
+    input = sys.stdin.read
+    data = input().split()
+
+    v = int(data[0])
+    e = int(data[1])
+
+    edges = []
+    index = 2
+    for _ in range(e):
+        v1 = int(data[index])
+        v2 = int(data[index + 1])
+        val = int(data[index + 2])
+        edges.append(Edge(v1, v2, val))
+        index += 3
+
+    result_val = kruskal(v, edges)
+    print(result_val)
+ 
+```
+
+
 ### Go
 
 ### Rust