solves #684: Redundant Connection in java

Author: anishLearnsToCode

README.md

@@ -379,6 +379,7 @@
 | 674  | [Longest Continuous Increasing Subsequence](https://leetcode.com/problems/longest-continuous-increasing-subsequence)                                                   |                                 [![Java](assets/java.png)](src/LongestContinuousIncreasingSubsequence.java) [![Python](assets/python.png)](python/longest_continuous_increasing_subsequence.py)                                  |                                                                                                                                   |
 | 680  | [Valid Palindrome II](https://leetcode.com/problems/valid-palindrome-ii)                                                                                               |                                                      [![Java](assets/java.png)](src/ValidPalindromeII.java) [![Python](assets/python.png)](python/valid_pallindrome_ii.py)                                                       |                                                                                                                                   |
 | 682  | [Baseball Game](https://leetcode.com/problems/baseball-game)                                                                                                           |                                                            [![Java](assets/java.png)](src/BaseballGame.java) [![Python](assets/python.png)](python/baseball_game.py)                                                             |                                                                                                                                   |
+| 684  | [Redundant Connection](https://leetcode.com/problems/redundant-connection)                                                                                             |                                                                                     [![Java](assets/java.png)](src/RedundantConnection.java)                                                                                     |                                                                                                                                   |
 | 686  | [Repeated String Match](https://leetcode.com/problems/repeated-string-match)                                                                                           |                                                                                                                                                                                                                                  |                                                                                                                                   |
 | 687  | [Longest Univalue Path](https://leetcode.com/problems/longest-univalue-path)                                                                                           |                                                                                                                                                                                                                                  |                                                                                                                                   |
 | 688  | [Knight Probability in Chessboard](https://leetcode.com/problems/knight-probability-in-chessboard)                                                                     |                                                                                [![Java](assets/java.png)](src/KnightProbabilityInChessboard.java)                                                                                |                                                                                                                                   |

src/GraphValidTree.java

@@ -31,9 +31,9 @@ public void union(int x, int y) {
             if (rootX == rootY) {
                 return;
             }
-            if (root[rootX] < root[rootY]) {
+            if (rank[rootX] < rank[rootY]) {
                 root[rootX] = rootY;
-            } else if (root[rootX] > root[rootY]) {
+            } else if (rank[rootX] > rank[rootY]) {
                 root[rootY] = rootX;
             } else {
                 root[rootY] = rootX;

src/RedundantConnection.java

@@ -0,0 +1,55 @@
+// https://leetcode.com/problems/redundant-connection
+// T: O(N)
+// S: O(N)
+
+public class RedundantConnection {
+    private static final class DisjointSet {
+        private final int[] root, rank;
+
+        public DisjointSet(int size) {
+            this.root = new int[size];
+            this.rank = new int[size];
+            for (int i = 0 ; i < size ; i++) {
+                root[i] = i;
+                rank[i] = 1;
+            }
+        }
+
+        public int find(int num) {
+            if (num == root[num]) {
+                return num;
+            }
+            return root[num] = find(root[num]);
+        }
+
+        public boolean areConnected(int x, int y) {
+            return find(x) == find(y);
+        }
+
+        public void union(int x, int y) {
+            final int rootX = find(x), rootY = find(y);
+            if (rootX == rootY) {
+                return;
+            }
+            if (rank[rootX] < rank[rootY]) {
+                root[rootY] = rootX;
+            } else if (rank[rootX] > rank[rootY]) {
+                root[rootY] = rootX;
+            } else {
+                root[rootY] = rootX;
+                rank[rootX]++;
+            }
+        }
+    }
+
+    public int[] findRedundantConnection(int[][] edges) {
+        final DisjointSet disjointSet = new DisjointSet(edges.length);
+        for (int[] edge : edges) {
+            if (disjointSet.areConnected(edge[0] - 1, edge[1] - 1)) {
+                return edge;
+            }
+            disjointSet.union(edge[0] - 1, edge[1] - 1);
+        }
+        return new int[] {};
+    }
+}