Is Graph Bipartite? - Practice Coding Problems

Is Graph Bipartite? - Problem

Imagine you need to organize a networking event where people can only talk to others from a different group. You're given a social network graph where each person is connected to their acquaintances.

Your task is to determine if you can divide all attendees into exactly two groups such that:

Every person only knows people from the opposite group
No one knows anyone from their same group

You're given an undirected graph with n nodes (people), where graph[u] contains all the people that person u knows. The graph has no self-connections and may have multiple disconnected components (separate friend circles).

Goal: Return true if the social network can be perfectly divided into two groups with the networking constraint, false otherwise.

Input & Output

example_1.py — Simple Bipartite Graph

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

› Output: false

💡 Note: The graph forms a 4-cycle (square), but nodes 0,1,2 form a triangle. Since triangles are odd cycles, this graph cannot be colored with 2 colors and is not bipartite.

example_2.py — Valid Bipartite Graph

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

› Output: true

💡 Note: We can divide the nodes into two groups: Group A = {0,2} and Group B = {1,3}. Every edge connects a node from Group A to Group B, satisfying the bipartite condition.

example_3.py — Disconnected Components

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

› Output: true

💡 Note: The graph has two disconnected components: {0,1} and {2,3}. Each component is bipartite (just an edge), so the entire graph is bipartite.

Visualization

Tap to expand

Understanding the Visualization

Assign Teams

Start by putting the first person in Team Red. All their connections must go to Team Blue.

Propagate Rules

Everyone Team Red knows goes to Team Blue, and everyone Team Blue knows goes to Team Red.

Check Conflicts

If we ever need to put someone in both teams, it's impossible to organize the event.

Handle Groups

Repeat for separate friend circles that aren't connected to the main group.

Key Takeaway

🎯 Key Insight: A graph is bipartite if we can divide all nodes into two groups where every edge connects different groups. This is equivalent to checking if the graph can be colored with only 2 colors!

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each vertex once and each edge once during DFS traversal

✓ Linear Growth

Space Complexity

O(V)

Color array storage plus recursion stack depth

✓ Linear Space

Constraints

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

Asked in

G Google 15 f Facebook 12 ⊞ Microsoft 8 a Amazon 6

The optimal solution uses graph coloring with DFS to determine if a graph is bipartite. The key insight is that a graph is bipartite if and only if it can be 2-colored (no adjacent nodes share the same color). We perform DFS from each unvisited node, assigning alternating colors. If we encounter a coloring conflict, the graph contains an odd cycle and is not bipartite. Time complexity: O(V + E), Space: O(V).

Common Approaches

Approach	Time	Space	Notes
✓ Graph Coloring with DFS (Optimal)	O(V + E)	O(V)	Use DFS to assign colors to nodes, ensuring adjacent nodes have different colors
Brute Force (Try All Partitions)	O(2^n * m)	O(n)	Generate all possible ways to divide nodes into two groups and check validity

Graph Coloring with DFS (Optimal) — Algorithm Steps

Create a color array to track node assignments (-1 = unvisited, 0/1 = group colors)
For each unvisited node, start DFS with color 0
During DFS, assign opposite colors to adjacent nodes
If we try to color a visited node with a different color than assigned, return false
If all components can be properly colored, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin DFS from unvisited node, assign color 0

Color Neighbors

Assign opposite color (1) to all neighbors

Check Conflicts

If neighbor already has same color, graph is not bipartite

Continue Recursively

Repeat process for all unvisited neighbors

Code -

solution.c — C

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

bool dfs(int** graph, int* graphColSize, int* color, int node, int c) {
    color[node] = c;
    for (int i = 0; i < graphColSize[node]; i++) {
        int neighbor = graph[node][i];
        if (color[neighbor] == c) { // Same color conflict
            return false;
        }
        if (color[neighbor] == -1 && !dfs(graph, graphColSize, color, neighbor, 1 - c)) {
            return false;
        }
    }
    return true;
}

bool isBipartite(int** graph, int* graphColSize, int graphSize) {
    int* color = (int*)malloc(graphSize * sizeof(int));
    for (int i = 0; i < graphSize; i++) {
        color[i] = -1; // -1: unvisited, 0/1: colors
    }
    
    for (int i = 0; i < graphSize; i++) {
        if (color[i] == -1) {
            if (!dfs(graph, graphColSize, color, i, 0)) {
                free(color);
                return false;
            }
        }
    }
    
    free(color);
    return true;
}

int main() {
    // Input parsing would go here
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each vertex once and each edge once during DFS traversal

✓ Linear Growth

Space Complexity

O(V)

Color array storage plus recursion stack depth

✓ Linear Space

Constraints

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

78.5K Views

Medium Frequency

~18 min Avg. Time

3.2K 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

Graph Coloring with DFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler