From 46f5e5cbaee1ec57e79ab029f351a8bfcd841e8a Mon Sep 17 00:00:00 2001
From: chayan das <110921638+Chayandas07@users.noreply.github.com>
Date: Thu, 30 Jan 2025 21:24:18 +0530
Subject: [PATCH] Create 2493. Divide Nodes Into the Maximum Number of Groups

---
 ...de Nodes Into the Maximum Number of Groups | 91 +++++++++++++++++++
 1 file changed, 91 insertions(+)
 create mode 100644 2493. Divide Nodes Into the Maximum Number of Groups

diff --git a/2493. Divide Nodes Into the Maximum Number of Groups b/2493. Divide Nodes Into the Maximum Number of Groups
new file mode 100644
index 0000000..6b6ac95
--- /dev/null
+++ b/2493. Divide Nodes Into the Maximum Number of Groups	
@@ -0,0 +1,91 @@
+class Solution {
+public:
+    int magnificentSets(int n, vector<vector<int>>& edges) {
+        vector<vector<int>> adj(n + 1);
+        for (auto& edge : edges) {
+            adj[edge[0]].push_back(edge[1]);
+            adj[edge[1]].push_back(edge[0]);
+        }
+        
+        vector<int> color(n + 1, 0);
+        vector<vector<int>> components;
+        
+        function<bool(int, vector<int>&)> bfs = [&](int start, vector<int>& component) {
+            queue<int> q;
+            q.push(start);
+            color[start] = 1;
+            component.push_back(start);
+            
+            while (!q.empty()) {
+                int node = q.front();
+                q.pop();
+                
+                for (int neighbor : adj[node]) {
+                    if (color[neighbor] == 0) {
+                        color[neighbor] = -color[node];
+                        q.push(neighbor);
+                        component.push_back(neighbor);
+                    } else if (color[neighbor] == color[node]) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        };
+        
+        for (int i = 1; i <= n; i++) {
+            if (color[i] == 0) {
+                vector<int> component;
+                if (!bfs(i, component)) {
+                    return -1;
+                }
+                components.push_back(component);
+            }
+        }
+        
+        int maxGroups = 0;
+        
+        auto getMaxDepth = [&](int start) {
+            queue<int> q;
+            unordered_map<int, int> dist;
+            q.push(start);
+            dist[start] = 1;
+            int maxDepth = 1;
+            
+            while (!q.empty()) {
+                int node = q.front();
+                q.pop();
+                
+                for (int neighbor : adj[node]) {
+                    if (!dist.count(neighbor)) {
+                        dist[neighbor] = dist[node] + 1;
+                        q.push(neighbor);
+                        maxDepth = max(maxDepth, dist[neighbor]);
+                    }
+                }
+            }
+            return maxDepth;
+        };
+        
+        for (auto& component : components) {
+            int localMax = 0;
+            for (int node : component) {
+                localMax = max(localMax, getMaxDepth(node));
+            }
+            maxGroups += localMax;
+        }
+        
+        return maxGroups;
+    }
+};
+
+int Main() {
+    Solution sol;
+    vector<vector<int>> edges1 = {{1,2},{1,4},{1,5},{2,6},{2,3},{4,6}};
+    cout << sol.magnificentSets(6, edges1) << endl;
+    
+    vector<vector<int>> edges2 = {{1,2},{2,3},{3,1}};
+    cout << sol.magnificentSets(3, edges2) << endl;
+    
+    return 0;
+}