solves #952: Largest Component Size by Common Factor in java

Author: anishLearnsToCode

Diff for: README.md

@@ -458,6 +458,7 @@
 | 942  | [DI String Match](https://leetcode.com/problems/di-string-match)                                                                                                       |                                                                                        [![Java](assets/java.png)](src/DIStringMatch.java)                                                                                        |                                                                                                                                   |
 | 944  | [Delete Columns to Make Sorted](https://leetcode.com/problems/delete-columns-to-make-sorted)                                                                           |                                                                                  [![Java](assets/java.png)](src/DeleteColumnsToMakeSorted.java)                                                                                  |                                                                                                                                   |
 | 949  | [Largest Time for Given Digits](https://leetcode.com/problems/largest-time-for-given-digits)                                                                           |                                                                                                                                                                                                                                  |                                                                                                                                   |
+| 952  | [Largest Component Size by Common Factor](https://leetcode.com/problems/largest-component-size-by-common-factor)                                                       |                                                                             [![Java](assets/java.png)](src/LargestComponentSizeByCommonFactor.java)                                                                              |                                                                                                                                   |
 | 953  | [Verifying an Alien Dictionary](https://leetcode.com/problems/verifying-an-alien-dictionary)                                                                           |                                                                                   [![Java](assets/java.png)](src/VerifyAnAlienDictionary.java)                                                                                   |                                                                                                                                   |
 | 961  | [N-Repeated Elements in Size 2N Array](https://leetcode.com/problems/n-repeated-element-in-size-2n-array)                                                              |                                                                                [![Java](assets/java.png)](src/NRepeatedElementInSizeNArray.java)                                                                                 |                                                                                                                                   |
 | 965  | [Univalued Binary Tree](https://leetcode.com/problems/univalued-binary-tree)                                                                                           |                                                                                     [![Java](assets/java.png)](src/UnivaluedBinaryTree.java)                                                                                     |                                                                                                                                   |

Diff for: src/LargestComponentSizeByCommonFactor.java

@@ -0,0 +1,78 @@
+// https://leetcode.com/problems/largest-component-size-by-common-factor
+// N = nums, M = max(N)
+// T: O(M + N sqrt(M) al(M) + N al(N)) al = inverse Ackermann function
+// S: O(M + N)
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+public class LargestComponentSizeByCommonFactor {
+    private static final class DisjointSet {
+        private final int[] root, rank;
+
+        public DisjointSet(int size) {
+            root = new int[size];
+            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 size() {
+            return root.length;
+        }
+    }
+
+    public int largestComponentSize(int[] nums) {
+        final int maxValue = Arrays.stream(nums).max().getAsInt();
+        final DisjointSet disjointSet = new DisjointSet(maxValue + 1);
+        for (int number : nums) {
+            for (int i = 2 ; i * i <= number ; i++) {
+                if (number % i == 0) {
+                    disjointSet.union(number, i);
+                    disjointSet.union(number, number/ i);
+                }
+            }
+        }
+        return largestComponentSize(disjointSet, nums);
+    }
+
+    private static int largestComponentSize(DisjointSet disjointSet, int[] numbers) {
+        final Map<Integer, Integer> rootFrequencies = new HashMap<>();
+        int maxSize = 1;
+        for (int number : numbers) {
+            final int root = disjointSet.find(number);
+            rootFrequencies.put(root, rootFrequencies.getOrDefault(root, 0) + 1);
+            maxSize = Math.max(maxSize, rootFrequencies.get(root));
+        }
+        return maxSize;
+    }
+}