Divide Nodes Into the Maximum Number of Groups

Divide Nodes Into the Maximum Number of Groups - Problem

You're given an undirected graph with n nodes labeled from 1 to n, and your mission is to organize these nodes into groups with a special constraint.

Think of it like organizing people at a party where friends must be in adjacent groups - if two people are friends (connected by an edge), they can only be in groups that differ by exactly 1 (like group 2 and group 3, but not group 1 and group 3).

Your goal: Find the maximum number of groups you can create while satisfying this constraint. If it's impossible to group the nodes this way, return -1.

Key constraint: For every edge [a, b], if node a is in group x and node b is in group y, then |y - x| = 1.

This is essentially asking: what's the longest path in each connected component of the graph, since nodes along a path can be arranged in consecutive groups!

Input & Output

example_1.py — Linear Chain

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

› Output: 4

💡 Note: The graph has a longest path of length 3 (like 6→2→1→4), so we can create 4 groups: Group 1: [6], Group 2: [2], Group 3: [1,5], Group 4: [4,3]. Adjacent nodes are in consecutive groups.

example_2.py — Triangle

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

› Output: -1

💡 Note: This forms a triangle (3-cycle). Since it's an odd cycle, the graph is not bipartite. No valid grouping exists because you can't assign consecutive group numbers to nodes in a triangle without violating the constraint.

example_3.py — Disconnected Components

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

› Output: 2

💡 Note: Two disconnected edges. Each edge forms a component with longest path = 1, so each needs 2 groups. The maximum across components is 2. Groups: [1,3] and [2,4].

Visualization

Tap to expand

Understanding the Visualization

Build Graph

Create connections between friend pairs (actors who must be in adjacent rows)

Check Components

For each group of connected actors, verify no conflicts exist (odd cycles)

Find Longest Chain

Determine the maximum chain length in each component using BFS

Calculate Rows

The longest chain determines minimum rows needed for that theater section

Key Takeaway

🎯 Key Insight: The problem is equivalent to finding the longest path in a bipartite graph. BFS gives us both the bipartite check and the longest path in optimal O(V + E) time!

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each vertex and edge once during BFS traversal of all components

✓ Linear Growth

Space Complexity

O(V + E)

Space for adjacency list, visited array, and BFS queue

✓ Linear Space

Constraints

1 ≤ n ≤ 500
0 ≤ edges.length ≤ 10⁴
edges[i].length == 2
1 ≤ a_i, b_i ≤ n
a_i != b_i
No duplicate edges in the input

Asked in

G Google 42 f Meta 38 a Amazon 35 ⊞ Microsoft 28

The optimal solution uses BFS traversal to simultaneously check if each connected component is bipartite (no odd cycles) and find the longest path. The key insight is that the maximum groups needed equals the longest path length + 1, but only if the graph contains no odd cycles.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Groupings)	O(n^n)	O(n)	Try every possible way to assign nodes to groups and check validity
BFS Longest Path + Bipartite Check (Optimal)	O(V + E)	O(V + E)	Check graph validity and find longest paths in each component using BFS

Brute Force (Try All Groupings) — Algorithm Steps

Generate all possible group assignments (1 to n groups)
For each assignment, check if adjacent nodes are in consecutive groups
Track the maximum valid number of groups found
Return the maximum or -1 if no valid assignment exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Assignment

Try assigning nodes to different groups systematically

Validate Constraints

Check if adjacent nodes are in consecutive groups

Track Maximum

Keep track of the maximum valid group count found

Code -

solution.c — C

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

bool isValidAssignment(int* assignment, int** edges, int edgeCount) {
    for (int i = 0; i < edgeCount; i++) {
        int diff = assignment[edges[i][0]] - assignment[edges[i][1]];
        if (diff < 0) diff = -diff;
        if (diff != 1) {
            return false;
        }
    }
    return true;
}

bool tryAssignment(int* assignment, int node, int n, int numGroups, int** edges, int edgeCount) {
    if (node > n) {
        return isValidAssignment(assignment, edges, edgeCount);
    }
    
    for (int group = 1; group <= numGroups; group++) {
        assignment[node] = group;
        if (tryAssignment(assignment, node + 1, n, numGroups, edges, edgeCount)) {
            return true;
        }
    }
    return false;
}

int magnificentGrouping(int n, int** edges, int edgeCount) {
    int* assignment = (int*)malloc((n + 1) * sizeof(int));
    int maxGroups = 0;
    
    // Try all possible number of groups
    for (int numGroups = 1; numGroups <= n; numGroups++) {
        if (tryAssignment(assignment, 1, n, numGroups, edges, edgeCount)) {
            maxGroups = numGroups;
        }
    }
    
    free(assignment);
    return maxGroups > 0 ? maxGroups : -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^n)

We try all possible ways to assign n nodes to up to n groups

✓ Linear Growth

Space Complexity

O(n)

Space to store current assignment and graph representation

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 500
0 ≤ edges.length ≤ 10⁴
edges[i].length == 2
1 ≤ a_i, b_i ≤ n
a_i != b_i
No duplicate edges in the input

28.4K Views

Medium-High Frequency

~25 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Groupings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler