diff --git a/problems/0684.冗余连接.md b/problems/0684.冗余连接.md
index c9eb33c4..bfbdeba9 100644
--- a/problems/0684.冗余连接.md
+++ b/problems/0684.冗余连接.md
@@ -10,6 +10,9 @@
 
 # 684.冗余连接
 
+
+[力扣题目链接](https://leetcode-cn.com/problems/redundant-connection/)
+
 树可以看成是一个连通且 无环 的 无向 图。
 
 给定往一棵 n 个节点 (节点值 1～n) 的树中添加一条边后的图。添加的边的两个顶点包含在 1 到 n 中间，且这条附加的边不属于树中已存在的边。图的信息记录于长度为 n 的二维数组 edges ，edges[i] = [ai, bi] 表示图中在 ai 和 bi 之间存在一条边。
@@ -140,16 +143,161 @@ public:
 ## Java
 
 ```java
+class Solution {
+    private int n;  // 节点数量3 到 1000
+    private int[] father;
+    public Solution() {
+        n = 1005;
+        father = new int[n];
+
+        // 并查集初始化
+        for (int i = 0; i < n; ++i) {
+            father[i] = i;
+        }
+    }
+
+    // 并查集里寻根的过程
+    private int find(int u) {
+        if(u == father[u]) {
+            return u;
+        }
+        father[u] = find(father[u]);
+        return father[u];
+    }
+
+    // 将v->u 这条边加入并查集
+    private void join(int u, int v) {
+        u = find(u);
+        v = find(v);
+        if (u == v) return ;
+        father[v] = u;
+    }
+
+    // 判断 u 和 v是否找到同一个根，本题用不上
+    private Boolean same(int u, int v) {
+        u = find(u);
+        v = find(v);
+        return u == v;
+    }
+
+    public int[] findRedundantConnection(int[][] edges) {
+        for (int i = 0; i < edges.length; i++) {
+            if (same(edges[i][0], edges[i][1])) {
+                return edges[i];
+            } else  {
+                join(edges[i][0], edges[i][1]);
+            }
+        }
+        return null;
+    }
+}
 ```
 
 ## Python
 
 ```python
+
+class Solution:
+
+    def __init__(self):
+        """
+        初始化
+        """
+        self.n = 1005
+        self.father = [i for i in range(self.n)]
+
+
+    def find(self, u):
+        """
+        并查集里寻根的过程
+        """
+        if u == self.father[u]:
+            return u
+        self.father[u] = self.find(self.father[u])
+        return self.father[u]
+
+    def join(self, u, v):
+        """
+        将v->u 这条边加入并查集
+        """
+        u = self.find(u)
+        v = self.find(v)
+        if u == v : return
+        self.father[v] = u
+        pass
+
+
+    def same(self, u, v ):
+        """
+        判断 u 和 v是否找到同一个根，本题用不上
+        """
+        u = self.find(u)
+        v = self.find(v)
+        return u == v
+
+    def findRedundantConnection(self, edges: List[List[int]]) -> List[int]:
+        for i in range(len(edges)):
+            if self.same(edges[i][0], edges[i][1]) :
+                return edges[i]
+            else :
+                self.join(edges[i][0], edges[i][1])
+        return []
 ```
 
 ## Go
 
 ```go
+
+// 全局变量
+var (
+    n = 1005 // 节点数量3 到 1000
+    father = make([]int, 1005)
+)
+
+// 并查集初始化
+func initialize() {
+	for i := 0; i < n; i++ {
+		father[i] = i
+	}
+}
+
+// 并查集里寻根的过程
+func find(u int) int {
+	if u == father[u] {
+		return u
+	}
+	father[u] = find(father[u])
+	return father[u]
+}
+
+// 将v->u 这条边加入并查集
+func join(u, v int) {
+	u = find(u)
+	v = find(v)
+	if u == v {
+		return
+	}
+	father[v] = u
+}
+
+// 判断 u 和 v是否找到同一个根，本题用不上
+func same(u, v int) bool {
+	u = find(u)
+	v = find(v)
+	return u == v
+}
+
+func findRedundantConnection(edges [][]int) []int {
+	initialize()
+	for i := 0; i < len(edges); i++ {
+		if same(edges[i][0], edges[i][1]) {
+			return edges[i]
+		} else {
+			join(edges[i][0], edges[i][1])
+		}
+	}
+	return []int{}
+}
 ```
 
 ## JavaScript