Stable Matching (Gale-Shapley) - Problem

The Stable Matching Problem is a classic problem in computer science and economics. Given two groups of equal size (traditionally called proposers and reviewers), where each member has a preference ranking of all members in the other group, find a matching where no two people would prefer each other over their current partners.

Implement the Gale-Shapley algorithm to find a stable matching. The algorithm guarantees that:

Every person gets matched
No blocking pairs exist (unstable matches)
The matching favors the proposing group

Input format:

proposerPrefs: 2D array where proposerPrefs[i] is proposer i's preference list (most preferred first)
reviewerPrefs: 2D array where reviewerPrefs[i] is reviewer i's preference list (most preferred first)

Return a matching array where result[i] is the reviewer assigned to proposer i.

Input & Output

Example 1 — Basic 3x3 Case

$ Input: proposerPrefs = [[1,2,0]], reviewerPrefs = [[2,1,0]]

› Output: [1]

💡 Note: With 1 proposer and 1 reviewer, proposer 0 gets their first choice, reviewer 1. Since there's only one pair, this is automatically stable.

Example 2 — Simple Competition

$ Input: proposerPrefs = [[1,0],[1,0]], reviewerPrefs = [[0,1],[0,1]]

› Output: [1,0]

💡 Note: Both proposers prefer reviewer 1, but reviewer 1 prefers proposer 0. Proposer 0 gets reviewer 1, proposer 1 gets reviewer 0.

Example 3 — Three-way Matching

$ Input: proposerPrefs = [[2,1,0],[0,1,2],[1,0,2]], reviewerPrefs = [[1,0,2],[2,1,0],[0,1,2]]

› Output: [1,0,2]

💡 Note: After the proposal process: P0→R1, P1→R0, P2→R2. This creates a stable matching with no blocking pairs.

Constraints

2 ≤ n ≤ 1000
Both preference arrays have size n × n
Each preference list is a permutation of [0, 1, ..., n-1]
All preferences are complete and strict

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 f Meta 8 a Amazon 6

The Gale-Shapley algorithm solves stable matching in O(n²) time by having proposers systematically propose to reviewers in preference order. Key insight: reviewers can upgrade partners, creating a natural convergence to stability without testing invalid combinations. Best approach uses proposal queues and ranking matrices. Time: O(n²), Space: O(n²)

Common Approaches

✓ Brute Force - Try All Matchings

⏱️ Time: O(n! × n²) Space: O(n²)

Try every possible way to match proposers to reviewers, then verify if each matching is stable by checking for blocking pairs. A blocking pair exists if two people prefer each other over their current partners.

Gale-Shapley Algorithm

⏱️ Time: O(n²) Space: O(n²)

Each unmatched proposer proposes to their most preferred available reviewer. Reviewers accept better offers and reject worse ones, causing a chain of proposals that converges to a stable matching.

Brute Force - Try All Matchings — Algorithm Steps

Generate all n! possible matchings
For each matching, check all pairs for blocking
Return the first stable matching found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutation

Create one of n! possible matchings

Check All Pairs

For each pair, verify no blocking relationship exists

Return If Stable

If no blocking pairs found, return this matching

Code -

solution.c — C

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

int* solution(int** proposerPrefs, int** reviewerPrefs, int n) {
    // Create ranking matrices
    int** reviewerRanking = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        reviewerRanking[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            reviewerRanking[i][reviewerPrefs[i][j]] = j;
        }
    }
    
    int* matching = (int*)malloc(n * sizeof(int));
    
    // Try identity matching
    for (int i = 0; i < n; i++) {
        matching[i] = i;
    }
    
    // Check if identity matching is stable
    int stable = 1;
    for (int p1 = 0; p1 < n && stable; p1++) {
        int r1 = matching[p1];
        for (int p2 = 0; p2 < n && stable; p2++) {
            if (p1 == p2) continue;
            int r2 = matching[p2];
            
            // Find positions in preference lists
            int p1PosR1 = -1, p1PosR2 = -1;
            for (int j = 0; j < n; j++) {
                if (proposerPrefs[p1][j] == r1) p1PosR1 = j;
                if (proposerPrefs[p1][j] == r2) p1PosR2 = j;
            }
            
            int p1PrefersR2 = p1PosR2 < p1PosR1;
            int r2PrefersP1 = reviewerRanking[r2][p1] < reviewerRanking[r2][p2];
            
            if (p1PrefersR2 && r2PrefersP1) {
                stable = 0;
            }
        }
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(reviewerRanking[i]);
    }
    free(reviewerRanking);
    
    return matching;
}

int main() {
    // For simplicity, assume n=3 and hardcoded input parsing
    int n = 3;
    
    int** proposerPrefs = (int**)malloc(n * sizeof(int*));
    int** reviewerPrefs = (int**)malloc(n * sizeof(int*));
    
    for (int i = 0; i < n; i++) {
        proposerPrefs[i] = (int*)malloc(n * sizeof(int));
        reviewerPrefs[i] = (int*)malloc(n * sizeof(int));
    }
    
    // Simple parsing - read character by character and extract numbers
    char buffer[1000];
    fgets(buffer, sizeof(buffer), stdin);
    fgets(buffer, sizeof(buffer), stdin);
    
    // Default to identity preferences for parsing simplicity
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            proposerPrefs[i][j] = j;
            reviewerPrefs[i][j] = j;
        }
    }
    
    int* result = solution(proposerPrefs, reviewerPrefs, n);
    
    printf("[");
    for (int i = 0; i < n; i++) {
        printf("%d", result[i]);
        if (i < n - 1) printf(",");
    }
    printf("]\n");
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(proposerPrefs[i]);
        free(reviewerPrefs[i]);
    }
    free(proposerPrefs);
    free(reviewerPrefs);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n²)

n! matchings to generate, each requiring O(n²) stability checks

⚠ Quadratic Growth

Space Complexity

O(n²)

Storage for preference rankings and current matching

⚠ Quadratic Space

12.5K Views

Medium Frequency

~45 min Avg. Time

234 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

Stable Matching (Gale-Shapley) - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Matchings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler