HDU 1522 -- Marriage is Stable (模板题&总结稳定婚姻算法)

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1522

Marriage is Stable

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 1299    Accepted Submission(s): 690
Special Judge

Problem Description

Albert, Brad, Chuck are happy bachelors who are in love with Laura, Marcy, Nancy. They all have three choices. But in fact, they do have some preference in mind. Say Albert, he likes Laura best, but that doesn't necesarily mean Laura likes him. Laura likes Chuck more than Albert. So if Albert can't marry Laura, he thinks Nancy a sensible choice. For Albert, he orders the girls Laura > Nancy > Marcy.

For the boys:

Albert: Laura > Nancy > Marcy
Brad: Marcy > Nancy > Laura
Chuck: Laura > Marcy > Nancy

For the girls:

Laura: Chuck > Albert > Brad
Marcy: Albert > Chuck > Brad
Nancy: Brad > Albert > Chuck

But if they were matched randomly, such as

Albert <-> Laura 
Brad <-> Marcy
Chuck <-> Nancy

they would soon discover it's not a nice solution. For Laura, she likes Chuck instead of Albert. And what's more, Chuck likes Laura better than Nancy. So Laura and Chuck are likely to come together, leaving poor Albert and Nancy.

Now it's your turn to find a stable marriage. A stable marriage means for any boy G and girl M, with their choice m[G] and m[M], it will not happen that rank(G, M) < rank(G, m[G]）and rank(M, G) < rank(M, m[M]).

 

 

Input

Each case starts with an integer n (1 <= n <= 500), the number of matches to make.

The following n lines contain n + 1 names each, the first being name of the boy, and rest being the rank of the girls.

The following n lines are the same information for the girls.

Process to the end of file.

 

 

Output

If there is a stable marriage, print n lines with two names on each line. You can choose any one if there are multiple solution. Print "Impossible" otherwise.

Print a blank line after each test.

 

 

Sample Input

3

Albert Laura Nancy Marcy

Brad Marcy Nancy Laura

Chuck Laura Marcy Nancy

Laura Chuck Albert Brad

Marcy Albert Chuck Brad

Nancy Brad Albert Chuck

 

 

Sample Output

Albert Nancy

Brad Marcy

Chuck Laura

 

 

稳定婚姻算法(G-S算法)介绍：

一、问题引入

有n个男生n个女生，每个男生依照喜欢程度对n个女生进行了排序，同理每个女生也依照喜欢程度对n个男生进行了排序，现要将他们一一配对，要求所有的配对是稳定的，即不会出现一个女生相对自己配对的男生更喜欢另一个男生，而这个男生也更喜欢她的情况。

二、算法步骤描述：

  第一轮，每个男人都选择自己名单上排在首位的女人，并向她表白。这种时候会出现两种情况：

（1）该女士还没有被男生追求过，则该女士接受该男生的请求。

（2）若该女生已经接受过其他男生的追求，那么该女生会将该男士与她的现任男友进行比较，若更喜欢她的男友，那么拒绝这个人的追求，否则，抛弃其男友……

  第一轮结束后，有些男人已经有女朋友了，有些男人仍然是单身。

       在第二轮追女行动中，每个单身男都从所有还没拒绝过他的女孩中选出自己最中意的那一个，并向她表白，不管她现在是否是单身。这种时候还是会遇到上面所说的两种情况，还是同样的解决方案。直到所有人都不再是单身。

 三、算法总结：

（1）无论男子的迭代排序如何，G-S算法每次返回的匹配S都是唯一的；

（2）匹配S中所有求爱方的伴侣是他们各自的最佳有效伴侣(the best valid partner)；

（3）匹配S中所有被求爱方的伴侣是他们各自的最差有效伴侣(the wrost valid partner)；

（4）也就是说，对于任意可以进行稳定匹配的二分图，对于任意点集，其最佳(差)有效伴侣是互不相同的。

题意：有n个男生和n个女生，每行给出每个人的名字，后面跟着对n个异性的好感度排名，要求输出男女两两结合的稳定婚姻匹配。

解析：此题关键在于将字符串之间的关系转换成编号关系，然后套用稳定婚姻算法即可，下面为AC代码(可作为稳定匹配算法模板)。

#include <iostream>
#include <cstring>
#include <map>
#include <string>
#define MAXN 510
using namespace std;
int mm[MAXN][MAXN], gg[MAXN][MAXN], p[MAXN];  // p[i]表示第i个boy已表白人数
// mm[i][j]表示第i个girl对编号为j的boy的好感排位，gg[i][j]表示第i个boy第j喜欢的girl编号，注意意义不同
int gg_match[MAXN], mm_match[MAXN];  // gg_match[i]表示第i个boy已匹配的girl编号
string ss[MAXN*2], str;   // ss[i]表示编号为i的name
map<string, int> mp_mm, mp_gg;  // name映射编号

int main() {
    int n;
    while (cin >> n) {
        mp_gg.clear(); mp_mm.clear();
        int cnt = 0;  // 按照girl出现次序给予编号
        for (int i = 1; i <= n; i++) {
            cin >> ss[i];
            mp_gg[ss[i]] = i;
            for (int j = 1; j <= n; j++) {
                cin >> str;
                if (mp_mm[str] == 0) {
                    mp_mm[str] = ++cnt;
                    ss[n+cnt] = str;
                }
                gg[i][j] = mp_mm[str];
            }
        }
        for (int i = 1; i <= n; i++) {
            cin >> str;
            int a = mp_mm[str];
            for (int j = 1; j <= n; j++) {
                cin >> str;
                int b = mp_gg[str];
                mm[a][b] = j;
            }
        }
        bool flag = true;  // 此处开始为算法核心代码，前面只是将字符串关系处理为编号关系
        for (int i = 1; i <= n; i++) p[i] = 1;
        memset(mm_match, -1, sizeof(mm_match));
        memset(gg_match, -1, sizeof(gg_match));
        while (flag) {
            flag = false;
            for (int i = 1; i <= n; i++) {
                if (gg_match[i] == -1 && p[i] <= n) {
                    int a = gg[i][p[i]++];
                    if (mm_match[a] == -1) mm_match[a] = i, gg_match[i] = a;
                    else if (mm[a][i] < mm[a][mm_match[a]]) {
                        gg_match[i] = a;
                        gg_match[mm_match[a]] = -1;
                        mm_match[a] = i;
                    }
                    flag = true;
                }
            }  // end for
        } // end while
        for (int i = 1; i <= n; i++) cout << ss[i] << ' ' << ss[gg_match[i]+n] << endl;
    }
    return 0;
}

顺便贴上另外两道稳定匹配题目的AC代码：

poj 3487 -- The Stable Marriage Problem

#include <iostream>
#include <cstring>
#include <map>
#define MAXN 30
using namespace std;
int mm[MAXN][MAXN], gg[MAXN][MAXN], p[MAXN];
int gg_match[MAXN], mm_match[MAXN];
char idx[2*MAXN];
map<char, int> mp;
int main() {
    int t, n;
    cin >> t;
    while (t--) {
        cin >> n;
        char ch;
        int cnt = 0;
        mp.clear();
        for (int i = 0; i < 2 * n; i++) cin >> ch;
        for (int i = 1; i <= n; i++) {
            cin >> idx[i] >> ch;
            mp[idx[i]] = i;
            for (int j = 1; j <= n; j++) {
                cin >> ch;
                if (mp[ch] == 0) {
                    mp[ch] = ++cnt;
                    idx[cnt+n] = ch;
                }
                gg[i][j] = mp[ch];
            }
        }
        for (int i = 1; i <= n; i++) {
            char gir;
            cin >> gir >> ch;
            int a = mp[gir];
            for (int j = 1; j <= n; j++) {
                cin >> ch;
                int b = mp[ch];
                mm[a][b] = j;
            }
        }
        bool flag = true;
        for (int i = 1; i <= n; i++) p[i] = 1;
        memset(mm_match, -1, sizeof(mm_match));
        memset(gg_match, -1, sizeof(gg_match));
        while (flag) {
            flag = false;
            for (int i = 1; i <= n; i++) {
                if (gg_match[i] == -1 && p[i] <= n) {
                    int a = gg[i][p[i]++];
                    if (mm_match[a] == -1) mm_match[a] = i, gg_match[i] = a;
                    else if (mm[a][i] < mm[a][mm_match[a]]) {
                        gg_match[i] = a;
                        gg_match[mm_match[a]] = -1;
                        mm_match[a] = i;
                    }
                    flag = true;
                }
            }
        }
        for (int i = 0; i < 26; i++) {
            for (int j = 1; j <= n; j++) if (idx[j] == 'a' + i) {
                cout << idx[j] << ' ' << idx[gg_match[j]+n] << endl;
                break;
            }
        }
        if (t) cout << endl;
    }
    return 0;
}

hdu 1435 -- Stable Match

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#define MAXN 210
using namespace std;
int gg[MAXN][MAXN], mm[MAXN][MAXN];
int gg_match[MAXN], mm_match[MAXN], p[MAXN];
struct node{
    double len;
    int cap, idx;
} aim[MAXN];
struct input{
    int idx, cap;
    double x, y, z;
} lau[MAXN], acc[MAXN];
bool cmp(const node &a, const node &b) {
    if (fabs(a.len - b.len) < 0.000001) return a.cap > b.cap;
    else return a.len < b.len;
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n; cin >> n;
        for (int i = 1; i <= n; i++) cin >> lau[i].idx >> lau[i].cap >> lau[i].x >> lau[i].y >> lau[i].z;
        for (int i = 1; i <= n; i++) cin >> acc[i].idx >> acc[i].cap >> acc[i].x >> acc[i].y >> acc[i].z;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                aim[j].len = sqrt((lau[i].x-acc[j].x)*(lau[i].x-acc[j].x) + (lau[i].y-acc[j].y)*(lau[i].y-acc[j].y) + (lau[i].z-acc[j].z)*(lau[i].z-acc[j].z));
                aim[j].cap = acc[j].cap; aim[j].idx = acc[j].idx;
            }
            sort(aim+1, aim+n+1, cmp);
            for (int j = 1; j <= n; j++) gg[lau[i].idx][j] = aim[j].idx;
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                aim[j].len = sqrt((acc[i].x-lau[j].x)*(acc[i].x-lau[j].x) + (acc[i].y-lau[j].y)*(acc[i].y-lau[j].y) + (acc[i].z-lau[j].z)*(acc[i].z-lau[j].z));
                aim[j].cap = lau[j].cap; aim[j].idx = lau[j].idx;
            }
            sort(aim+1, aim+n+1, cmp);
            for (int j = 1; j <= n; j++) mm[acc[i].idx][aim[j].idx] = j;
        }
        bool flag = true;
        for (int i = 1; i <= n; i++) p[i] = 1;
        memset(mm_match, -1, sizeof(mm_match));
        memset(gg_match, -1, sizeof(gg_match));
        while (flag) {
            flag = false;
            for (int i = 1; i <= n; i++) {
                if (gg_match[i] == -1 && p[i] <= n) {
                    int a = gg[i][p[i]++];
                    if (mm_match[a] == -1) mm_match[a] = i, gg_match[i] = a;
                    else if (mm[a][i] < mm[a][mm_match[a]]) {
                        gg_match[i] = a;
                        gg_match[mm_match[a]] = -1;
                        mm_match[a] = i;
                    }
                    flag = true;
                }
            }
        }
        for (int i = 1; i <= n; i++) cout << i << ' ' << gg_match[i] << endl;
        cout << endl;
    }
    return 0;
}