Is Graph Bipartite?

Is Graph Bipartite? - Problem

There is an undirected graph with n nodes, where each node is numbered between 0 and n - 1. You are given a 2D array graph, where graph[u] is an array of nodes that node u is adjacent to.

More formally, for each v in graph[u], there is an undirected edge between node u and node v.

The graph has the following properties:

There are no self-edges (graph[u] does not contain u)
There are no parallel edges (graph[u] does not contain duplicate values)
If v is in graph[u], then u is in graph[v] (the graph is undirected)
The graph may not be connected

A graph is bipartite if the nodes can be partitioned into two independent sets A and B such that every edge in the graph connects a node in set A and a node in set B.

Return true if and only if it is bipartite.

Input & Output

Example 1 — Simple Bipartite Graph

$ Input: graph = [[1,2,3],[0,2],[0,1,3],[0,2]]

› Output: false

💡 Note: This graph has edges: 0-1, 0-2, 0-3, 1-2, 2-3. It contains a triangle (3-cycle): 0-1-2-0. Since triangles are odd cycles, the graph cannot be bipartite. If we try to color 0 as blue, then 1 and 2 must be red, but since 1 and 2 are connected, they cannot both be red.

Example 2 — Tree Structure

$ Input: graph = [[1,3],[0,2],[1,3],[0,2]]

› Output: true

💡 Note: This forms a 4-cycle: 0-1-2-3-0. We can color it as: Set A = {0,2}, Set B = {1,3}. All edges connect different sets, so it's bipartite.

Example 3 — Odd Cycle

$ Input: graph = [[1,2],[0,2],[0,1]]

› Output: false

💡 Note: This is a triangle (3-cycle). Triangles are odd cycles and cannot be bipartite. If we color 0 as blue, then 1 and 2 must be red, but 1 and 2 are connected.

Constraints

1 ≤ graph.length ≤ 100
0 ≤ graph[u].length < graph.length
0 ≤ graph[u][i] ≤ graph.length - 1
graph[u] does not contain u
All the values of graph[u] are unique
If graph[u] contains v, then graph[v] contains u

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 10 f Facebook 8

The key insight is that a graph is bipartite if and only if it contains no odd-length cycles. Best approach is DFS/BFS graph coloring - try to color the graph with two colors such that no adjacent nodes have the same color. Time: O(V + E), Space: O(V)

Common Approaches

✓ BFS Graph Coloring

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

Similar to DFS approach but uses BFS (queue-based) to traverse the graph. Start from each unvisited node and color it, then use BFS to color all reachable nodes with alternating colors. This avoids potential stack overflow issues with deep recursion.

Brute Force - Try All Partitions

⏱️ Time: O(n × 2ⁿ) Space: O(n)

Try every possible way to split the n nodes into two groups A and B, then check if every edge connects nodes from different groups. This requires checking 2^n different partitions.

DFS Graph Coloring

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

Traverse the graph using DFS and try to color each node with alternating colors. If we can color the entire graph without conflicts, it's bipartite. Handle disconnected components by starting DFS from unvisited nodes.

BFS Graph Coloring — Algorithm Steps

Initialize color array with -1 (uncolored)
For each uncolored node, start BFS with color 0
Process queue: color current node, add uncolored neighbors with opposite color
If neighbor already has same color, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start BFS from node 0, color it blue

Process Level

Color all neighbors with opposite color

Continue BFS

Process next level, check for conflicts

Code -

solution.c — C

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

typedef struct {
    int* data;
    int front;
    int rear;
    int size;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->data = (int*)malloc(capacity * sizeof(int));
    q->front = 0;
    q->rear = -1;
    q->size = 0;
    return q;
}

void enqueue(Queue* q, int val) {
    q->rear++;
    q->data[q->rear] = val;
    q->size++;
}

int dequeue(Queue* q) {
    int val = q->data[q->front];
    q->front++;
    q->size--;
    return val;
}

bool isEmpty(Queue* q) {
    return q->size == 0;
}

bool bfs(int** graph, int* graphSizes, int* color, int start, int n) {
    Queue* queue = createQueue(n);
    enqueue(queue, start);
    color[start] = 0;
    
    while (!isEmpty(queue)) {
        int node = dequeue(queue);
        for (int i = 0; i < graphSizes[node]; i++) {
            int neighbor = graph[node][i];
            if (color[neighbor] == color[node]) { // Same color conflict
                free(queue->data);
                free(queue);
                return false;
            }
            if (color[neighbor] == -1) {
                color[neighbor] = 1 - color[node];
                enqueue(queue, neighbor);
            }
        }
    }
    free(queue->data);
    free(queue);
    return true;
}

bool solution(int** graph, int* graphSizes, int graphSize) {
    int* color = (int*)malloc(graphSize * sizeof(int));
    for (int i = 0; i < graphSize; i++) {
        color[i] = -1; // -1: uncolored, 0: color A, 1: color B
    }
    
    // Check all components
    for (int i = 0; i < graphSize; i++) {
        if (color[i] == -1) {
            if (!bfs(graph, graphSizes, color, i, graphSize)) {
                free(color);
                return false;
            }
        }
    }
    free(color);
    return true;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for [[1,2],[2,3],[1,3]] format
    int graph[100][100];
    int graphSizes[100];
    int graphSize = 0;
    
    char* ptr = line + 1; // Skip first [
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            graphSizes[graphSize] = 0;
            while (*ptr != ']') {
                int num = 0;
                while (*ptr >= '0' && *ptr <= '9') {
                    num = num * 10 + (*ptr - '0');
                    ptr++;
                }
                graph[graphSize][graphSizes[graphSize]++] = num;
                if (*ptr == ',') ptr++;
            }
            ptr++; // Skip ]
            graphSize++;
        }
        if (*ptr == ',') ptr++;
    }
    
    int* graphPtrs[100];
    for (int i = 0; i < graphSize; i++) {
        graphPtrs[i] = graph[i];
    }
    
    printf(solution(graphPtrs, graphSizes, graphSize) ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each vertex once and each edge once during BFS traversal

✓ Linear Growth

Space Complexity

O(V)

Color array of size V plus BFS queue storing up to V nodes

⚡ Linearithmic Space

78.0K Views

Medium Frequency

~25 min Avg. Time

2.1K 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 Graph Coloring — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler