# Stable Marriage Problem

The Stable Marriage Problem states that given N men and N women, where each person has ranked all members of the opposite sex in order of preference, marry the men and women together such that there are no two people of opposite sex who would both rather have each other than their current partners. If there are no such people, all the marriages are “stable” (Source Wiki).

Consider the following example.

Let there be two men m1 and m2 and two women w1 and w2.
Let m1‘s list of preferences be {w1, w2}
Let m2‘s list of preferences be {w1, w2}
Let w1‘s list of preferences be {m1, m2}
Let w2‘s list of preferences be {m1, m2}

The matching { {m1, w2}, {w1, m2} } is not stable because m1 and w1 would prefer each other over their assigned partners. The matching {m1, w1} and {m2, w2} is stable because there are no two people of opposite sex that would prefer each other over their assigned partners.

It is always possible to form stable marriages from lists of preferences (See references for proof). Following is Gale–Shapley algorithm to find a stable matching:
The idea is to iterate through all free men while there is any free man available. Every free man goes to all women in his preference list according to the order. For every woman he goes to, he checks if the woman is free, if yes, they both become engaged. If the woman is not free, then the woman chooses either says no to him or dumps her current engagement according to her preference list. So an engagement done once can be broken if a woman gets better option. Time Complexity of Gale-Shapley Algorithm is O(n2).
Following is complete algorithm from Wiki

```Initialize all men and women to free
while there exist a free man m who still has a woman w to propose to
{
w = m's highest ranked such woman to whom he has not yet proposed
if w is free
(m, w) become engaged
else some pair (m', w) already exists
if w prefers m to m'
(m, w) become engaged
m' becomes free
else
(m', w) remain engaged
}```

Input & Output: Input is a 2D matrix of size (2*N)*N where N is number of women or men. Rows from 0 to N-1 represent preference lists of men and rows from N to 2*N – 1 represent preference lists of women. So men are numbered from 0 to N-1 and women are numbered from N to 2*N – 1. The output is list of married pairs.

Following is the implementation of the above algorithm.

## C++

 `// C++ program for stable marriage problem ` `#include ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `// Number of Men or Women ` `#define N  4 ` ` `  `// This function returns true if woman 'w' prefers man 'm1' over man 'm' ` `bool` `wPrefersM1OverM(``int` `prefer[2*N][N], ``int` `w, ``int` `m, ``int` `m1) ` `{ ` `    ``// Check if w prefers m over her current engagment m1 ` `    ``for` `(``int` `i = 0; i < N; i++) ` `    ``{ ` `        ``// If m1 comes before m in lisr of w, then w prefers her ` `        ``// cirrent engagement, don't do anything ` `        ``if` `(prefer[w][i] == m1) ` `            ``return` `true``; ` ` `  `        ``// If m cmes before m1 in w's list, then free her current ` `        ``// engagement and engage her with m ` `        ``if` `(prefer[w][i] == m) ` `           ``return` `false``; ` `    ``} ` `} ` ` `  `// Prints stable matching for N boys and N girls. Boys are numbered as 0 to ` `// N-1. Girls are numbereed as N to 2N-1. ` `void` `stableMarriage(``int` `prefer[2*N][N]) ` `{ ` `    ``// Stores partner of women. This is our output array that ` `    ``// stores paing information.  The value of wPartner[i] ` `    ``// indicates the partner assigned to woman N+i.  Note that ` `    ``// the woman numbers between N and 2*N-1. The value -1 ` `    ``// indicates that (N+i)'th woman is free ` `    ``int` `wPartner[N]; ` ` `  `    ``// An array to store availability of men.  If mFree[i] is ` `    ``// false, then man 'i' is free, otherwise engaged. ` `    ``bool` `mFree[N]; ` ` `  `    ``// Initialize all men and women as free ` `    ``memset``(wPartner, -1, ``sizeof``(wPartner)); ` `    ``memset``(mFree, ``false``, ``sizeof``(mFree)); ` `    ``int` `freeCount = N; ` ` `  `    ``// While there are free men ` `    ``while` `(freeCount > 0) ` `    ``{ ` `        ``// Pick the first free man (we could pick any) ` `        ``int` `m; ` `        ``for` `(m = 0; m < N; m++) ` `            ``if` `(mFree[m] == ``false``) ` `                ``break``; ` ` `  `        ``// One by one go to all women according to m's preferences. ` `        ``// Here m is the picked free man ` `        ``for` `(``int` `i = 0; i < N && mFree[m] == ``false``; i++) ` `        ``{ ` `            ``int` `w = prefer[m][i]; ` ` `  `            ``// The woman of preference is free, w and m become ` `            ``// partners (Note that the partnership maybe changed ` `            ``// later). So we can say they are engaged not married ` `            ``if` `(wPartner[w-N] == -1) ` `            ``{ ` `                ``wPartner[w-N] = m; ` `                ``mFree[m] = ``true``; ` `                ``freeCount--; ` `            ``} ` ` `  `            ``else`  `// If w is not free ` `            ``{ ` `                ``// Find current engagement of w ` `                ``int` `m1 = wPartner[w-N]; ` ` `  `                ``// If w prefers m over her current engagement m1, ` `                ``// then break the engagement between w and m1 and ` `                ``// engage m with w. ` `                ``if` `(wPrefersM1OverM(prefer, w, m, m1) == ``false``) ` `                ``{ ` `                    ``wPartner[w-N] = m; ` `                    ``mFree[m] = ``true``; ` `                    ``mFree[m1] = ``false``; ` `                ``} ` `            ``} ``// End of Else ` `        ``} ``// End of the for loop that goes to all women in m's list ` `    ``} ``// End of main while loop ` ` `  ` `  `    ``// Print the solution ` `    ``cout << ``"Woman   Man"` `<< endl; ` `    ``for` `(``int` `i = 0; i < N; i++) ` `       ``cout << ``" "` `<< i+N << ``"\t"` `<< wPartner[i] << endl; ` `} ` ` `  `// Driver program to test above functions ` `int` `main() ` `{ ` `    ``int` `prefer[2*N][N] = { {7, 5, 6, 4}, ` `        ``{5, 4, 6, 7}, ` `        ``{4, 5, 6, 7}, ` `        ``{4, 5, 6, 7}, ` `        ``{0, 1, 2, 3}, ` `        ``{0, 1, 2, 3}, ` `        ``{0, 1, 2, 3}, ` `        ``{0, 1, 2, 3}, ` `    ``}; ` `    ``stableMarriage(prefer); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program for stable marriage problem  ` `import` `java.util.*; ` ` `  `class` `GFG ` `{  ` ` `  `// Number of Men or Women  ` `static` `int` `N = ``4``;  ` ` `  `// This function returns true if woman  ` `// 'w' prefers man 'm1' over man 'm'  ` `static` `boolean` `wPrefersM1OverM(``int` `prefer[][], ``int` `w,  ` `                               ``int` `m, ``int` `m1)  ` `{  ` `    ``// Check if w prefers m over  ` `    ``// her current engagment m1  ` `    ``for` `(``int` `i = ``0``; i < N; i++)  ` `    ``{  ` `        ``// If m1 comes before m in lisr of w,  ` `        ``// then w prefers her current engagement, ` `        ``// don't do anything  ` `        ``if` `(prefer[w][i] == m1)  ` `            ``return` `true``;  ` ` `  `        ``// If m cmes before m1 in w's list,  ` `        ``// then free her current engagement ` `        ``// and engage her with m  ` `        ``if` `(prefer[w][i] == m)  ` `        ``return` `false``;  ` `    ``} ` `    ``return` `false``; ` `}  ` ` `  `// Prints stable matching for N boys and ` `// N girls. Boys are numbered as 0 to  ` `// N-1. Girls are numbereed as N to 2N-1.  ` `static` `void` `stableMarriage(``int` `prefer[][])  ` `{  ` `    ``// Stores partner of women. This is our ` `    ``// output array that stores paing information.  ` `    ``// The value of wPartner[i] indicates the partner  ` `    ``// assigned to woman N+i. Note that the woman  ` `    ``// numbers between N and 2*N-1. The value -1  ` `    ``// indicates that (N+i)'th woman is free  ` `    ``int` `wPartner[] = ``new` `int``[N];  ` ` `  `    ``// An array to store availability of men.  ` `    ``// If mFree[i] is false, then man 'i' is  ` `    ``// free, otherwise engaged.  ` `    ``boolean` `mFree[] = ``new` `boolean``[N];  ` ` `  `    ``// Initialize all men and women as free  ` `    ``Arrays.fill(wPartner, -``1``);  ` `    ``int` `freeCount = N;  ` ` `  `    ``// While there are free men  ` `    ``while` `(freeCount > ``0``)  ` `    ``{  ` `        ``// Pick the first free man  ` `        ``// (we could pick any)  ` `        ``int` `m;  ` `        ``for` `(m = ``0``; m < N; m++)  ` `            ``if` `(mFree[m] == ``false``)  ` `                ``break``;  ` ` `  `        ``// One by one go to all women  ` `        ``// according to m's preferences.  ` `        ``// Here m is the picked free man  ` `        ``for` `(``int` `i = ``0``; i < N &&  ` `                        ``mFree[m] == ``false``; i++)  ` `        ``{  ` `            ``int` `w = prefer[m][i];  ` ` `  `            ``// The woman of preference is free,  ` `            ``// w and m become partners (Note that  ` `            ``// the partnership maybe changed later). ` `            ``// So we can say they are engaged not married  ` `            ``if` `(wPartner[w - N] == -``1``)  ` `            ``{  ` `                ``wPartner[w - N] = m;  ` `                ``mFree[m] = ``true``;  ` `                ``freeCount--;  ` `            ``}  ` ` `  `            ``else` `// If w is not free  ` `            ``{  ` `                ``// Find current engagement of w  ` `                ``int` `m1 = wPartner[w - N];  ` ` `  `                ``// If w prefers m over her current engagement m1,  ` `                ``// then break the engagement between w and m1 and  ` `                ``// engage m with w.  ` `                ``if` `(wPrefersM1OverM(prefer, w, m, m1) == ``false``)  ` `                ``{  ` `                    ``wPartner[w - N] = m;  ` `                    ``mFree[m] = ``true``;  ` `                    ``mFree[m1] = ``false``;  ` `                ``}  ` `            ``} ``// End of Else  ` `        ``} ``// End of the for loop that goes  ` `          ``// to all women in m's list  ` `    ``} ``// End of main while loop  ` ` `  ` `  `// Print the solution  ` `System.out.println(``"Woman Man"``);  ` `for` `(``int` `i = ``0``; i < N; i++)  ` `{ ` `    ``System.out.print(``" "``);  ` `    ``System.out.println(i + N + ``"     "` `+  ` `                           ``wPartner[i]); ` `} ` `}  ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args)  ` `{  ` `    ``int` `prefer[][] = ``new` `int``[][]{{``7``, ``5``, ``6``, ``4``},  ` `                                 ``{``5``, ``4``, ``6``, ``7``},  ` `                                 ``{``4``, ``5``, ``6``, ``7``},  ` `                                 ``{``4``, ``5``, ``6``, ``7``},  ` `                                 ``{``0``, ``1``, ``2``, ``3``},  ` `                                 ``{``0``, ``1``, ``2``, ``3``},  ` `                                 ``{``0``, ``1``, ``2``, ``3``},  ` `                                 ``{``0``, ``1``, ``2``, ``3``}};  ` `    ``stableMarriage(prefer);  ` `} ` `}  ` ` `  `// This code is contributed by Prerna Saini `

## Python3

 `# Python3 program for stable marriage problem ` ` `  `# Number of Men or Women ` `N ``=` `4` ` `  `# This function returns true if  ` `# woman 'w' prefers man 'm1' over man 'm' ` `def` `wPrefersM1OverM(prefer, w, m, m1): ` `     `  `    ``# Check if w prefers m over her  ` `    ``# current engagment m1 ` `    ``for` `i ``in` `range``(N): ` `         `  `        ``# If m1 comes before m in lisr of w,  ` `        ``# then w prefers her current engagement, ` `        ``# don't do anything ` `        ``if` `(prefer[w][i] ``=``=` `m1): ` `            ``return` `True` ` `  `        ``# If m cmes before m1 in w's list,  ` `        ``# then free her current engagement  ` `        ``# and engage her with m ` `        ``if` `(prefer[w][i] ``=``=` `m): ` `            ``return` `False` ` `  `# Prints stable matching for N boys and N girls.  ` `# Boys are numbered as 0 to N-1.  ` `# Girls are numbereed as N to 2N-1. ` `def` `stableMarriage(prefer): ` `     `  `    ``# Stores partner of women. This is our output  ` `    ``# array that stores paing information.  ` `    ``# The value of wPartner[i] indicates the partner  ` `    ``# assigned to woman N+i. Note that the woman numbers  ` `    ``# between N and 2*N-1. The value -1 indicates  ` `    ``# that (N+i)'th woman is free ` `    ``wPartner ``=` `[``-``1` `for` `i ``in` `range``(N)] ` ` `  `    ``# An array to store availability of men.  ` `    ``# If mFree[i] is false, then man 'i' is free, ` `    ``# otherwise engaged. ` `    ``mFree ``=` `[``False` `for` `i ``in` `range``(N)] ` ` `  `    ``freeCount ``=` `N ` ` `  `    ``# While there are free men ` `    ``while` `(freeCount > ``0``): ` `         `  `        ``# Pick the first free man (we could pick any) ` `        ``m ``=` `0` `        ``while` `(m < N): ` `            ``if` `(mFree[m] ``=``=` `False``): ` `                ``break` `            ``m ``+``=` `1` ` `  `        ``# One by one go to all women according to  ` `        ``# m's preferences. Here m is the picked free man ` `        ``i ``=` `0` `        ``while` `i < N ``and` `mFree[m] ``=``=` `False``: ` `            ``w ``=` `prefer[m][i] ` ` `  `            ``# The woman of preference is free,  ` `            ``# w and m become partners (Note that  ` `            ``# the partnership maybe changed later).  ` `            ``# So we can say they are engaged not married ` `            ``if` `(wPartner[w ``-` `N] ``=``=` `-``1``): ` `                ``wPartner[w ``-` `N] ``=` `m ` `                ``mFree[m] ``=` `True` `                ``freeCount ``-``=` `1` ` `  `            ``else``:  ` `                 `  `                ``# If w is not free ` `                ``# Find current engagement of w ` `                ``m1 ``=` `wPartner[w ``-` `N] ` ` `  `                ``# If w prefers m over her current engagement m1, ` `                ``# then break the engagement between w and m1 and ` `                ``# engage m with w. ` `                ``if` `(wPrefersM1OverM(prefer, w, m, m1) ``=``=` `False``): ` `                    ``wPartner[w ``-` `N] ``=` `m ` `                    ``mFree[m] ``=` `True` `                    ``mFree[m1] ``=` `False` `            ``i ``+``=` `1` ` `  `            ``# End of Else ` `        ``# End of the for loop that goes  ` `        ``# to all women in m's list ` `    ``# End of main while loop ` ` `  `    ``# Prthe solution ` `    ``print``(``"Woman "``, ``" Man"``) ` `    ``for` `i ``in` `range``(N): ` `        ``print``(i ``+` `N, ``"\t"``, wPartner[i]) ` ` `  `# Driver Code ` `prefer ``=` `[[``7``, ``5``, ``6``, ``4``], [``5``, ``4``, ``6``, ``7``], ` `          ``[``4``, ``5``, ``6``, ``7``], [``4``, ``5``, ``6``, ``7``], ` `          ``[``0``, ``1``, ``2``, ``3``], [``0``, ``1``, ``2``, ``3``], ` `          ``[``0``, ``1``, ``2``, ``3``], [``0``, ``1``, ``2``, ``3``]] ` ` `  `stableMarriage(prefer) ` ` `  `# This code is contributed by Mohit Kumar `

## C#

 `// C# program for stable marriage problem  ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG  ` `{  ` ` `  `// Number of Men or Women  ` `static` `int` `N = 4;  ` ` `  `// This function returns true if woman  ` `// 'w' prefers man 'm1' over man 'm'  ` `static` `bool` `wPrefersM1OverM(``int` `[,]prefer, ``int` `w,  ` `                            ``int` `m, ``int` `m1)  ` `{  ` `    ``// Check if w prefers m over  ` `    ``// her current engagment m1  ` `    ``for` `(``int` `i = 0; i < N; i++)  ` `    ``{  ` `        ``// If m1 comes before m in lisr of w,  ` `        ``// then w prefers her current engagement,  ` `        ``// don't do anything  ` `        ``if` `(prefer[w, i] == m1)  ` `            ``return` `true``;  ` ` `  `        ``// If m cmes before m1 in w's list,  ` `        ``// then free her current engagement  ` `        ``// and engage her with m  ` `        ``if` `(prefer[w, i] == m)  ` `        ``return` `false``;  ` `    ``}  ` `    ``return` `false``;  ` `}  ` ` `  `// Prints stable matching for N boys and  ` `// N girls. Boys are numbered as 0 to  ` `// N-1. Girls are numbereed as N to 2N-1.  ` `static` `void` `stableMarriage(``int` `[,]prefer)  ` `{  ` `    ``// Stores partner of women. This is our  ` `    ``// output array that stores paing information.  ` `    ``// The value of wPartner[i] indicates the partner  ` `    ``// assigned to woman N+i. Note that the woman  ` `    ``// numbers between N and 2*N-1. The value -1  ` `    ``// indicates that (N+i)'th woman is free  ` `    ``int` `[]wPartner = ``new` `int``[N];  ` ` `  `    ``// An array to store availability of men.  ` `    ``// If mFree[i] is false, then man 'i' is  ` `    ``// free, otherwise engaged.  ` `    ``bool` `[]mFree = ``new` `bool``[N];  ` ` `  `    ``// Initialize all men and women as free  ` `    ``for` `(``int` `i = 0; i < N; i++)  ` `        ``wPartner[i] = -1; ` `    ``int` `freeCount = N;  ` ` `  `    ``// While there are free men  ` `    ``while` `(freeCount > 0)  ` `    ``{  ` `        ``// Pick the first free man  ` `        ``// (we could pick any)  ` `        ``int` `m;  ` `        ``for` `(m = 0; m < N; m++)  ` `            ``if` `(mFree[m] == ``false``)  ` `                ``break``;  ` ` `  `        ``// One by one go to all women  ` `        ``// according to m's preferences.  ` `        ``// Here m is the picked free man  ` `        ``for` `(``int` `i = 0; i < N &&  ` `                        ``mFree[m] == ``false``; i++)  ` `        ``{  ` `            ``int` `w = prefer[m,i];  ` ` `  `            ``// The woman of preference is free,  ` `            ``// w and m become partners (Note that  ` `            ``// the partnership maybe changed later).  ` `            ``// So we can say they are engaged not married  ` `            ``if` `(wPartner[w - N] == -1)  ` `            ``{  ` `                ``wPartner[w - N] = m;  ` `                ``mFree[m] = ``true``;  ` `                ``freeCount--;  ` `            ``}  ` ` `  `            ``else` `// If w is not free  ` `            ``{  ` `                ``// Find current engagement of w  ` `                ``int` `m1 = wPartner[w - N];  ` ` `  `                ``// If w prefers m over her current engagement m1,  ` `                ``// then break the engagement between w and m1 and  ` `                ``// engage m with w.  ` `                ``if` `(wPrefersM1OverM(prefer, w, m, m1) == ``false``)  ` `                ``{  ` `                    ``wPartner[w - N] = m;  ` `                    ``mFree[m] = ``true``;  ` `                    ``mFree[m1] = ``false``;  ` `                ``}  ` `            ``} ``// End of Else  ` `        ``} ``// End of the for loop that goes  ` `         ``// to all women in m's list  ` `    ``} ``// End of main while loop  ` ` `  `    ``// Print the solution  ` `    ``Console.WriteLine(``"Woman Man"``);  ` `    ``for` `(``int` `i = 0; i < N; i++)  ` `    ``{  ` `        ``Console.Write(``" "``);  ` `        ``Console.WriteLine(i + N + ``"     "` `+  ` `                              ``wPartner[i]);  ` `    ``}  ` `}  ` ` `  `// Driver Code  ` `public` `static` `void` `Main(String[] args)  ` `{  ` `    ``int` `[,]prefer = ``new` `int``[,]{{7, 5, 6, 4}, ` `                               ``{5, 4, 6, 7}, ` `                               ``{4, 5, 6, 7}, ` `                               ``{4, 5, 6, 7}, ` `                               ``{0, 1, 2, 3}, ` `                               ``{0, 1, 2, 3}, ` `                               ``{0, 1, 2, 3}, ` `                               ``{0, 1, 2, 3}}; ` `    ``stableMarriage(prefer);  ` `}  ` `}  ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```Woman   Man
4      2
5      1
6      3
7      0
```

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

7

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.