Add solution #2493

Author: JoshCrozier

README.md

@@ -481,6 +481,7 @@
 2469|[Convert the Temperature](./2469-convert-the-temperature.js)|Easy|
 2482|[Difference Between Ones and Zeros in Row and Column](./2482-difference-between-ones-and-zeros-in-row-and-column.js)|Medium|
 2490|[Circular Sentence](./2490-circular-sentence.js)|Easy|
+2493|[Divide Nodes Into the Maximum Number of Groups](./2493-divide-nodes-into-the-maximum-number-of-groups.js)|Hard|
 2529|[Maximum Count of Positive Integer and Negative Integer](./2529-maximum-count-of-positive-integer-and-negative-integer.js)|Easy|
 2535|[Difference Between Element Sum and Digit Sum of an Array](./2535-difference-between-element-sum-and-digit-sum-of-an-array.js)|Easy|
 2618|[Check if Object Instance of Class](./2618-check-if-object-instance-of-class.js)|Medium|

solutions/2493-divide-nodes-into-the-maximum-number-of-groups.js

@@ -0,0 +1,61 @@
+/**
+ * 2493. Divide Nodes Into the Maximum Number of Groups
+ * https://leetcode.com/problems/divide-nodes-into-the-maximum-number-of-groups/
+ * Difficulty: Hard
+ *
+ * You are given a positive integer n representing the number of nodes in an undirected graph.
+ * The nodes are labeled from 1 to n.
+ *
+ * You are also given a 2D integer array edges, where edges[i] = [ai, bi] indicates that there
+ * is a bidirectional edge between nodes ai and bi. Notice that the given graph may be disconnected.
+ *
+ * Divide the nodes of the graph into m groups (1-indexed) such that:
+ * - Each node in the graph belongs to exactly one group.
+ * - For every pair of nodes in the graph that are connected by an edge [ai, bi], if ai belongs to
+ *   the group with index x, and bi belongs to the group with index y, then |y - x| = 1.
+ *
+ * Return the maximum number of groups (i.e., maximum m) into which you can divide the nodes.
+ * Return -1 if it is impossible to group the nodes with the given conditions.
+ */
+
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number}
+ */
+var magnificentSets = function(n, edges) {
+  const graph = new Array(n).fill().map(() => []);
+  for (const [i, j] of edges) {
+    graph[i - 1].push(j - 1);
+    graph[j - 1].push(i - 1);
+  }
+
+  const result = new Array(n).fill(0);
+  for (let i = 0; i < n; i++) {
+    const groups = new Array(n).fill(0);
+    const queue = [i];
+    let max = 1;
+    let root = i;
+
+    groups[i] = 1;
+
+    while (queue.length) {
+      const key = queue.shift();
+      root = Math.min(root, key);
+
+      for (const node of graph[key]) {
+        if (groups[node] === 0) {
+          groups[node] = groups[key] + 1;
+          max = Math.max(max, groups[node]);
+          queue.push(node);
+        } else if (Math.abs(groups[node] - groups[key]) !== 1) {
+          return -1;
+        }
+      }
+    }
+
+    result[root] = Math.max(result[root], max);
+  }
+
+  return result.reduce((a, b) => a + b);
+};