Add solution #952

Author: JoshCrozier

README.md

@@ -1,4 +1,4 @@
-# 1,037 LeetCode solutions in JavaScript
+# 1,038 LeetCode solutions in JavaScript
 
 [https://leetcode.com/](https://leetcode.com/)
 
@@ -761,6 +761,7 @@
 949|[Largest Time for Given Digits](./solutions/0949-largest-time-for-given-digits.js)|Medium|
 950|[Reveal Cards In Increasing Order](./solutions/0950-reveal-cards-in-increasing-order.js)|Medium|
 951|[Flip Equivalent Binary Trees](./solutions/0951-flip-equivalent-binary-trees.js)|Medium|
+952|[Largest Component Size by Common Factor](./solutions/0952-largest-component-size-by-common-factor.js)|Hard|
 966|[Vowel Spellchecker](./solutions/0966-vowel-spellchecker.js)|Medium|
 970|[Powerful Integers](./solutions/0970-powerful-integers.js)|Easy|
 976|[Largest Perimeter Triangle](./solutions/0976-largest-perimeter-triangle.js)|Easy|

solutions/0952-largest-component-size-by-common-factor.js

@@ -0,0 +1,64 @@
+/**
+ * 952. Largest Component Size by Common Factor
+ * https://leetcode.com/problems/largest-component-size-by-common-factor/
+ * Difficulty: Hard
+ *
+ * You are given an integer array of unique positive integers nums. Consider the following graph:
+ * - There are nums.length nodes, labeled nums[0] to nums[nums.length - 1],
+ * - There is an undirected edge between nums[i] and nums[j] if nums[i] and nums[j] share a common
+ *   factor greater than 1.
+ *
+ * Return the size of the largest connected component in the graph.
+ */
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var largestComponentSize = function(nums) {
+  const max = Math.max(...nums);
+  const parent = new Array(max + 1).fill().map((_, i) => i);
+  const rank = new Array(max + 1).fill(0);
+
+  for (const num of nums) {
+    for (let factor = 2; factor * factor <= num; factor++) {
+      if (num % factor === 0) {
+        union(parent, rank, num, factor);
+        union(parent, rank, num, num / factor);
+      }
+    }
+  }
+
+  const map = new Map();
+  let result = 0;
+
+  for (const num of nums) {
+    const root = find(parent, num);
+    map.set(root, (map.get(root) || 0) + 1);
+    result = Math.max(result, map.get(root));
+  }
+
+  return result;
+
+  function find(parent, x) {
+    if (parent[x] !== x) {
+      parent[x] = find(parent, parent[x]);
+    }
+    return parent[x];
+  }
+
+  function union(parent, rank, x, y) {
+    const rootX = find(parent, x);
+    const rootY = find(parent, y);
+    if (rootX !== rootY) {
+      if (rank[rootX] < rank[rootY]) {
+        parent[rootX] = rootY;
+      } else if (rank[rootX] > rank[rootY]) {
+        parent[rootY] = rootX;
+      } else {
+        parent[rootY] = rootX;
+        rank[rootX]++;
+      }
+    }
+  }
+};