POJ 1904 (确定完全二分匹配的所有可能边)

http://poj.org/problem?id=1904

 

　　题意：有n个王子，有n个美女，每个王子可能同时喜欢多个美女，数据已经给出一组完全匹配的方案。问在满足所有王子都能完全匹配的情况下，每个王子能选择的对象分别有谁，按升序输出。（其实如标题的描述更简洁。。）

　　一开始可能会想，对于每个王子，先拆边，再重新挑选对象，判断可行性。注意到题目数据量很大，最多2000个节点，200000条边，如果直接暴力拆边判可行，复杂度就是O（N*N*M）……注意到题目已经给出了一组合法的方案，肯定是有用的。　　假设 A 王子和原配 B 美女解除关系，再匹配了 C 美女，那么 C 美女的原配 D 王子必定要重新再找另一个美女，如果任意一个王子能找回 B 美女匹配，证明 A 王子和 C 美女是可能的匹配对，否则就是不可能的匹配对。

　　构图：每个王子向喜欢的美女连接一条有向边，再根据匹配好的方案，每个美女向其匹配的王子连接一条有向边。。。构图后简化一下描述就是：如果从 A 点出发，最终能回到 A 点（成环）则能够维持完全匹配的，因此求一次强连通分量，判断每个王子与其喜欢的美女是否在同一强连通分量即可。（深感图论的题目很难描述啊，表示已经尽力了……）

代码：

// 5750 Ms
#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
#include <stack>
#include <queue>
#define N 5000
using namespace std;
 
vector<int> G1[N];
int dep[N], low[N], belg[N];
bool instack[N];
stack<int> sta;
int inx, cnt;
 
void DFS(int u)
{
    dep[u] = low[u] = inx++;
    sta.push(u); instack[u] = 1;
    for (int i = 0; i < G1[u].size(); i++) {
        int v = G1[u][i];
        if (dep[v] == -1) {
            DFS(v);
            low[u] = min(low[u], low[v]);
        }
        else if (instack[v])
            low[u] = min(low[u], dep[v]);
    }
    if (dep[u] == low[u]) {
        while (1) {
            int v = sta.top(); sta.pop();
            instack[v] = 0;
            belg[v] = cnt;
            if (u == v) break;
        }
        cnt++;
    }
}
 
int main()
{
    int n, k, tmp;
    while (scanf("%d", &n) != EOF) {
        memset(G1, 0, sizeof(G1));
        for (int i = 1; i <= n; i++) {
            scanf("%d", &k);
            while (k--) {
                scanf("%d", &tmp);
                G1[i].push_back(tmp+n);
            }
        }
        for (int i = 1; i <= n; i++) {
            scanf("%d", &tmp);
            G1[tmp+n].push_back(i);
        }
        //----------------------------构图
        inx = 0, cnt = 0;
        memset(dep, -1, sizeof(dep));
        memset(belg, -1, sizeof(belg));
        memset(instack, 0, sizeof(instack));
        for (int i = 1; i <= n; i++) {
            if (dep[i] == -1)
                DFS(i);
        }
        //----------------------------Tarjan
        for (int i = 1; i <= n; i++) {
            priority_queue<int, vector<int>, greater<int> > que;
            for (int j = 0; j < G1[i].size(); j++) {
                int v = G1[i][j];
                if (belg[v] == belg[i])
                    que.push(v-n);
            }
            printf("%d", que.size());
            while (!que.empty()) {
                printf(" %d", que.top()); que.pop();
            }
            printf("\n");
        }
        //----------------------------打印结果
    }
    return 0;
}