Divide Nodes Into the Maximum Number of Groups

Divide Nodes Into the Maximum Number of Groups - Problem

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.

Input & Output

Example 1 — Path Graph

$ Input: n = 6, edges = [[1,2],[1,3],[2,4],[4,5],[4,6]]

› Output: 4

💡 Note: The graph forms a tree. We can assign: node 3→group 1, node 1→group 2, node 2→group 3, nodes 4→group 4. Adjacent nodes differ by exactly 1 group.

Example 2 — Triangle (Odd Cycle)

$ Input: n = 3, edges = [[1,2],[2,3],[3,1]]

› Output: -1

💡 Note: This forms a triangle (3-cycle). It's impossible to assign groups where adjacent nodes always differ by 1, since we'd need 1→2→3→1 which is impossible.

Example 3 — Disconnected Components

$ Input: n = 4, edges = [[1,2],[3,4]]

› Output: 2

💡 Note: Two separate edges: 1-2 and 3-4. Each component needs 2 groups. Maximum across all components is 2.

Constraints

1 ≤ n ≤ 15
0 ≤ edges.length ≤ n * (n - 1) / 2
edges[i].length == 2
1 ≤ ai, bi ≤ n
ai ≠ bi
There are no duplicate edges.

Visualization

Tap to expand

Asked in

G Google 12 f Meta 8

This problem requires recognizing that the adjacent constraint creates a bipartite-like structure. The key insight is that if adjacent nodes must be in groups differing by exactly 1, then the graph must be bipartite (no odd cycles). The optimal approach uses BFS to check bipartiteness and find the diameter (longest path) of each component. Time: O(n²), Space: O(n).

Common Approaches

✓ BFS - Check Bipartiteness and Find Diameter

⏱️ Time: O(n * (n + m)) Space: O(n + m)

The constraint forces adjacent nodes to be in consecutive groups, making it a bipartite-like problem. First check if valid grouping exists, then use BFS from each node to find the longest path (maximum groups).

Brute Force - Try All Groupings

⏱️ Time: O(n^n) Space: O(n)

Try every possible way to assign nodes to groups from 1 to n, then check if adjacent constraint is satisfied. Keep track of maximum valid groups found.

BFS - Check Bipartiteness and Find Diameter — Algorithm Steps

Check if each component is bipartite using BFS
If not bipartite, return -1
For each component, BFS from each node to find diameter
Sum diameters of all components

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Bipartite

Use BFS to check if graph can be 2-colored

Find Diameter

BFS from each node to find longest path

Calculate Groups

Diameter + 1 gives maximum groups needed

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define MAXN 16
int adj[MAXN][MAXN];
int adjSize[MAXN];
int color[MAXN];
bool visited[MAXN];

bool isBipartite(int* component, int compSize) {
    memset(color, -1, sizeof(color));
    int queue[MAXN], front = 0, rear = 0;
    queue[rear++] = component[0];
    color[component[0]] = 0;
    
    while (front < rear) {
        int node = queue[front++];
        for (int i = 0; i < adjSize[node]; i++) {
            int neighbor = adj[node][i];
            if (color[neighbor] != -1) {
                if (color[neighbor] == color[node]) {
                    return false;
                }
            } else {
                color[neighbor] = 1 - color[node];
                queue[rear++] = neighbor;
            }
        }
    }
    return true;
}

int bfsMaxDistance(int start, bool* componentSet) {
    bool vis[MAXN];
    memset(vis, false, sizeof(vis));
    
    int queue[MAXN][2], front = 0, rear = 0;
    queue[rear][0] = start;
    queue[rear][1] = 0;
    rear++;
    vis[start] = true;
    int maxDist = 0;
    
    while (front < rear) {
        int node = queue[front][0];
        int dist = queue[front][1];
        front++;
        
        if (dist > maxDist) maxDist = dist;
        
        for (int i = 0; i < adjSize[node]; i++) {
            int neighbor = adj[node][i];
            if (!vis[neighbor] && componentSet[neighbor]) {
                vis[neighbor] = true;
                queue[rear][0] = neighbor;
                queue[rear][1] = dist + 1;
                rear++;
            }
        }
    }
    
    return maxDist;
}

int solution(int n, int edges[][2], int edgesSize) {
    memset(adjSize, 0, sizeof(adjSize));
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        adj[u][adjSize[u]++] = v;
        adj[v][adjSize[v]++] = u;
    }
    
    memset(visited, false, sizeof(visited));
    int totalGroups = 0;
    
    for (int start = 1; start <= n; start++) {
        if (visited[start]) continue;
        
        int component[MAXN], compSize = 0;
        int queue[MAXN], front = 0, rear = 0;
        queue[rear++] = start;
        visited[start] = true;
        
        while (front < rear) {
            int node = queue[front++];
            component[compSize++] = node;
            for (int i = 0; i < adjSize[node]; i++) {
                int neighbor = adj[node][i];
                if (!visited[neighbor]) {
                    visited[neighbor] = true;
                    queue[rear++] = neighbor;
                }
            }
        }
        
        if (!isBipartite(component, compSize)) {
            return -1;
        }
        
        bool componentSet[MAXN];
        memset(componentSet, false, sizeof(componentSet));
        for (int i = 0; i < compSize; i++) {
            componentSet[component[i]] = true;
        }
        
        int maxDist = 0;
        for (int i = 0; i < compSize; i++) {
            int dist = bfsMaxDistance(component[i], componentSet);
            if (dist > maxDist) maxDist = dist;
        }
        
        if (maxDist + 1 > totalGroups) {
            totalGroups = maxDist + 1;
        }
    }
    
    return totalGroups;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[1000];
    scanf(" %s", line);
    
    int edges[20][2];
    int edgesSize = 0;
    
    char* ptr = line + 1;
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            int u = 0, v = 0;
            while (*ptr >= '0' && *ptr <= '9') {
                u = u * 10 + (*ptr - '0');
                ptr++;
            }
            ptr++;
            while (*ptr >= '0' && *ptr <= '9') {
                v = v * 10 + (*ptr - '0');
                ptr++;
            }
            edges[edgesSize][0] = u;
            edges[edgesSize][1] = v;
            edgesSize++;
            ptr++;
        } else {
            ptr++;
        }
    }
    
    int result = solution(n, edges, edgesSize);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * (n + m))

BFS from each of n nodes takes O(n + m) time

✓ Linear Growth

Space Complexity

O(n + m)

Adjacency list and BFS queue storage

⚡ Linearithmic Space

8.9K Views

Medium Frequency

~35 min Avg. Time

234 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS - Check Bipartiteness and Find Diameter — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler