Classroom Seating Conflict

Classroom Seating Conflict - Problem

In a classroom of n students numbered 0 to n - 1, some pairs of students have conflicts and cannot sit in the same group.

You are given a 2D array conflicts where conflicts[i] = [u, v] means students u and v must be in different groups.

Return true if all students can be divided into exactly two groups such that no two conflicting students are in the same group, or false otherwise.

Input & Output

Example 1 — Possible Split

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

› Output: true

💡 Note: Group A: {0,2}, Group B: {1,3}. No conflicts within groups.

Example 2 — Odd Cycle

$ Input: n = 3, conflicts = [[0,1],[1,2],[0,2]]

› Output: false

💡 Note: Triangle: all three conflict with each other. Cannot split into 2 groups.

Example 3 — No Conflicts

$ Input: n = 1, conflicts = []

› Output: true

💡 Note: Single student, trivially split.

Constraints

1 ≤ n ≤ 2 × 10^5
0 ≤ conflicts.length ≤ 2 × 10^5
0 ≤ u, v < n

Visualization

Tap to expand

Asked in

a Amazon 0 G Google 0 M Meta 0

The key insight is that splitting into two groups is possible if and only if the conflict graph is bipartite — no odd-length cycles. BFS 2-coloring checks this directly. Union-Find with complement nodes provides an elegant alternative.

Common Approaches

✓ BFS 2-Coloring

⏱️ Time: O(V + E) Space: O(V + E)

Build adjacency list. For each unvisited node, assign color 0 and BFS. Assign opposite colors to neighbors. If a neighbor already has the same color as current node, return false.

Union-Find with Complement Nodes

⏱️ Time: O(E × α(V)) Space: O(V)

Create Union-Find of size 2n. For each conflict (u,v): union(u, v+n) and union(u+n, v). If find(u)==find(v) before union, they're forced into the same group — contradiction, return false.

BFS 2-Coloring — Algorithm Steps

Step 1: Build adjacency list from conflicts
Step 2: BFS from each uncolored node with color 0
Step 3: Assign opposite color to each neighbor
Step 4: If same-color conflict found, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Color node 0 as RED

Expand

Color neighbors 1,3 as BLUE

Continue

Color neighbor 2 as RED. All valid!

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#define MAXN 200001
#define MAXE 400002
int head[MAXN], to[MAXE], nxt[MAXE], ecnt;
int color[MAXN], queue[MAXN];
void addEdge(int u, int v) {
    to[ecnt] = v;
    nxt[ecnt] = head[u];
    head[u] = ecnt++;
    to[ecnt] = u;
    nxt[ecnt] = head[v];
    head[v] = ecnt++;
}
int main() {
    int n, ch, num, neg, u, v, i;
    ecnt = 0;
    memset(head, -1, sizeof(head));
    while ((ch = getchar()) != EOF && !(ch == '-' || (ch >= '0' && ch <= '9')))
        ;
    neg = 0;
    num = 0;
    if (ch == '-') {
        neg = 1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        num = num * 10 + (ch - '0');
        ch = getchar();
    }
    n = neg ? -num : num;
    while ((ch = getchar()) != EOF && ch != '[')
        ;
    while (1) {
        ch = getchar();
        if (ch == EOF || ch == ']')
            break;
        if (ch == '[') {
            while ((ch = getchar()) != EOF && !(ch == '-' || (ch >= '0' && ch <= '9')))
                ;
            neg = 0;
            num = 0;
            if (ch == '-') {
                neg = 1;
                ch = getchar();
            }
            while (ch >= '0' && ch <= '9') {
                num = num * 10 + (ch - '0');
                ch = getchar();
            }
            u = neg ? -num : num;
            while (ch != EOF && !(ch == '-' || (ch >= '0' && ch <= '9')))
                ch = getchar();
            neg = 0;
            num = 0;
            if (ch == '-') {
                neg = 1;
                ch = getchar();
            }
            while (ch >= '0' && ch <= '9') {
                num = num * 10 + (ch - '0');
                ch = getchar();
            }
            v = neg ? -num : num;
            addEdge(u, v);
            while (ch != ']' && ch != EOF)
                ch = getchar();
        }
    }
    memset(color, -1, sizeof(int) * n);
    int result = 1;
    for (int s = 0; s < n && result; s++) {
        if (color[s] != -1)
            continue;
        color[s] = 0;
        int front = 0, back = 0;
        queue[back++] = s;
        while (front < back && result) {
            int nd = queue[front++];
            for (i = head[nd]; i != -1; i = nxt[i]) {
                if (color[to[i]] == -1) {
                    color[to[i]] = 1 - color[nd];
                    queue[back++] = to[i];
                } else if (color[to[i]] == color[nd]) {
                    result = 0;
                    break;
                }
            }
        }
    }
    printf("%s\n", result ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each node and edge once

✓ Linear Growth

Space Complexity

O(V + E)

Adjacency list and color array

✓ Linear Space

6 Views

High Frequency

~15 min Avg. Time

0 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 2-Coloring — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler