Maximum Bipartite Matching - Problem

Given a bipartite graph represented as an adjacency list, find the maximum matching. A matching is a set of edges where no two edges share a common vertex. A maximum matching is a matching that contains the largest possible number of edges.

The bipartite graph has vertices divided into two disjoint sets: left vertices (numbered 0 to n-1) and right vertices (numbered 0 to m-1). The input provides an adjacency list where graph[i] contains all right vertices that left vertex i is connected to.

Return the size of the maximum matching.

Input & Output

Example 1 — Complete Bipartite Graph

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

› Output: 3

💡 Note: Perfect matching possible: Left 0→Right 1, Left 1→Right 2, Left 2→Right 0. All vertices matched.

Example 2 — Partial Matching

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

› Output: 2

💡 Note: Maximum matching: Left 0→Right 0, Left 1→Right 1. Left 2 cannot be matched (Right 0 already taken).

Example 3 — No Edges

$ Input: graph = [[],[],[]]

› Output: 0

💡 Note: No edges exist, so no matching is possible.

Constraints

1 ≤ graph.length ≤ 100
0 ≤ graph[i].length ≤ 100
0 ≤ graph[i][j] ≤ 99

Visualization

Tap to expand

Asked in

G Google 35 M Microsoft 28 A Amazon 22 f Facebook 18

The key insight is finding augmenting paths that allow incrementally improving the matching size. The Hungarian algorithm systematically searches for these paths using DFS, guaranteeing an optimal solution. Time: O(V³), Space: O(V²)

Common Approaches

✓ Brute Force - Try All Possible Matchings

⏱️ Time: O(2^n) Space: O(n)

Try every possible assignment of left vertices to right vertices, checking all combinations to find the maximum matching. This involves recursive backtracking through all valid assignments.

Hungarian Algorithm with Augmenting Paths

⏱️ Time: O(V³) Space: O(V²)

Systematically find augmenting paths (alternating unmatched/matched edges) that allow increasing the matching size by 1. Continue until no more augmenting paths exist.

Brute Force - Try All Possible Matchings — Algorithm Steps

Generate all possible ways to match left vertices to right vertices
For each combination, verify it's a valid matching (no shared vertices)
Track the maximum size found across all valid matchings

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Try all ways to assign left vertices to right vertices

Validate Matching

Check each combination is valid (no shared vertices)

Track Maximum

Keep the largest valid matching found

Code -

solution.c — C

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

int maxMatching = 0;

void backtrack(int** graph, int* graphSizes, int n, int leftIdx, int* usedRight, int rightSize, int currentMatching) {
    if (leftIdx == n) {
        if (currentMatching > maxMatching) {
            maxMatching = currentMatching;
        }
        return;
    }
    
    // Try not matching this left vertex
    backtrack(graph, graphSizes, n, leftIdx + 1, usedRight, rightSize, currentMatching);
    
    // Try matching this left vertex to each possible right vertex
    for (int i = 0; i < graphSizes[leftIdx]; i++) {
        int rightVertex = graph[leftIdx][i];
        if (!usedRight[rightVertex]) {
            usedRight[rightVertex] = 1;
            backtrack(graph, graphSizes, n, leftIdx + 1, usedRight, rightSize, currentMatching + 1);
            usedRight[rightVertex] = 0;
        }
    }
}

int solution(int** graph, int* graphSizes, int n) {
    if (n == 0) return 0;
    
    maxMatching = 0;
    int usedRight[1000] = {0}; // Assuming max 1000 right vertices
    backtrack(graph, graphSizes, n, 0, usedRight, 1000, 0);
    return maxMatching;
}

int main() {
    // Simple parsing for demonstration
    int n = 3;
    int** graph = malloc(n * sizeof(int*));
    int* graphSizes = malloc(n * sizeof(int));
    
    // Example: [[1,2],[0,2],[0,1]]
    graph[0] = malloc(2 * sizeof(int));
    graph[0][0] = 1; graph[0][1] = 2;
    graphSizes[0] = 2;
    
    graph[1] = malloc(2 * sizeof(int));
    graph[1][0] = 0; graph[1][1] = 2;
    graphSizes[1] = 2;
    
    graph[2] = malloc(2 * sizeof(int));
    graph[2][0] = 0; graph[2][1] = 1;
    graphSizes[2] = 2;
    
    int result = solution(graph, graphSizes, n);
    printf("%d\n", result);
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(graph[i]);
    }
    free(graph);
    free(graphSizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Explores all possible subsets of edges, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion depth and storage for current matching state

✓ Linear Space

30.3K Views

Medium Frequency

~35 min Avg. Time

890 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

Maximum Bipartite Matching - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Possible Matchings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler