Possible Bipartition - Practice Coding Problems

Possible Bipartition - Problem

Imagine you're organizing a debate tournament and need to split n people (labeled from 1 to n) into two opposing teams of any size. However, some people have personal conflicts and absolutely refuse to be on the same team!

You're given an integer n representing the total number of people and an array dislikes where dislikes[i] = [a_i, b_i] indicates that person a_i dislikes person b_i (and vice versa - it's mutual). Your task is to determine if it's possible to split everyone into exactly two teams such that no two people who dislike each other end up on the same team.

Return true if such a division is possible, false otherwise.

Example: If person 1 dislikes person 2, and person 2 dislikes person 3, then we could put persons 1 and 3 on Team A, and person 2 on Team B.

Input & Output

example_1.py — Basic case

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

› Output: true

💡 Note: We can divide into Team A: {1, 4} and Team B: {2, 3}. Person 1 dislikes 2 and 3 (both on Team B). Person 2 dislikes 1 (on Team A) and 4 (on Team A). No conflicts within teams.

example_2.py — Impossible case

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

› Output: false

💡 Note: This creates a triangle where everyone dislikes everyone else. No matter how we divide into 2 teams, there will always be two people who dislike each other on the same team.

example_3.py — Single person

$ Input: n = 1, dislikes = []

› Output: true

💡 Note: With only one person and no dislikes, we can always form a valid bipartition (person 1 goes to either team).

Constraints

1 ≤ n ≤ 2000
0 ≤ dislikes.length ≤ 10⁴
dislikes[i].length == 2
1 ≤ dislikes[i][j] ≤ n
a_i < b_i
All the pairs of dislikes are unique

Visualization

Tap to expand

Understanding the Visualization

Model as Graph

Each person is a node, dislikes are edges

Apply Graph Coloring

Try to color with 2 colors (teams)

DFS Traversal

Use DFS to assign alternating colors

Conflict Detection

If adjacent nodes have same color, return false

Key Takeaway

🎯 Key Insight: This problem is equivalent to determining if a graph is bipartite. We use graph coloring with DFS to assign people to two teams, ensuring no conflicts within teams.

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 24

The optimal approach treats this as a bipartite graph problem. Build an adjacency list from the dislikes, then use DFS graph coloring to attempt to color all people with exactly 2 colors (representing the two teams). If the graph can be 2-colored without conflicts, return true; otherwise return false. Time complexity: O(V + E).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n * m)	O(n)	Try every possible way to assign people to two groups
DFS Graph Coloring (Optimal)	O(V + E)	O(V + E)	Use DFS to color the conflict graph with two colors (teams)

Brute Force (Try All Combinations) — Algorithm Steps

Generate all 2^n possible assignments of people to two groups
For each assignment, check if any dislike pair is in the same group
If we find a valid assignment, return true
If no valid assignment exists, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Assignment

Create a binary assignment (0=Team A, 1=Team B)

Check Conflicts

Verify no dislike pairs are in same team

Continue or Return

If valid, return true; otherwise try next assignment

Code -

solution.c — C

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

bool isValidAssignment(int* assignment, int dislikes[][2], int m, int n) {
    for (int i = 0; i < m; i++) {
        if (assignment[dislikes[i][0]-1] == assignment[dislikes[i][1]-1]) {
            return false;
        }
    }
    return true;
}

bool possibleBipartition(int n, int dislikes[][2], int m) {
    int assignment[n];
    
    // Try all 2^n possible assignments
    for (int mask = 0; mask < (1 << n); mask++) {
        for (int i = 0; i < n; i++) {
            assignment[i] = (mask >> i) & 1;
        }
        
        if (isValidAssignment(assignment, dislikes, m, n)) {
            return true;
        }
    }
    return false;
}

int main() {
    int n, m;
    scanf("%d %d", &n, &m);
    int dislikes[m][2];
    // Input parsing implementation needed
    printf("%s\n", possibleBipartition(n, dislikes, m) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * m)

We try 2^n possible assignments, and for each assignment we check m dislike relationships

⚠ Quadratic Growth

Space Complexity

O(n)

Space to store current assignment and input data

⚡ Linearithmic Space

42.0K Views

High Frequency

~15 min Avg. Time

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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler