hdu 4685 二分匹配+强连通分量

题目链接：

http://acm.hdu.edu.cn/showproblem.php?pid=4685

题解：

这一题是poj 1904的加强版，poj 1904王子和公主的人数是一样多的，并且给出了一个完美匹配，而这一题王子和公主的人数是不同的，而且没有给出任何匹配。因此借鉴1904的做法，我们可以对这题做一些预处理，从而使得它和poj 1904一样能够用强连通分量来求解。

首先求出一个最大匹配，对于每一个没有匹配的王子，加一个虚拟的公主与之匹配，对于每一个没有匹配的公主，加一个虚拟的的王子与之匹配，这样就可以得到一个完美匹配了。并且使得所有的王子都与虚拟的公主连边，所有的公主都与每一个虚拟的王子相连

这样建完图后就可以和poj 1904一样的做法了。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<stack>
#include<algorithm>
using namespace std;

const int maxn = 2222;

int scan() {
    int ret = 0, flag = 0; char ch;
    if ((ch = getchar()) == '-') flag = 1;
    else if (ch >= '0'&&ch <= '9') ret = ch - '0';
    while ((ch = getchar()) >= '0'&&ch <= '9') ret = ret * 10 + ch - '0';
    return flag ? -ret : ret;
}

void out(int x) {
    if (x>9) out(x / 10);
    putchar(x % 10 + '0');
}

int _t[maxn], lef[maxn];

int n, m;

vector<int> G[maxn],G2[maxn];

//二分图的最大匹配----------------------------------------------- 
bool match(int u) {
    for (int i = 0; i < G[u].size(); i++) {
        int v = G[u][i];
        if (!_t[v]) {
            _t[v] = 1;
            if (lef[v]==-1 || match(lef[v])) {
                lef[v] = u;
                return true;
            }
        }
    }
    return false;
}

void BM() {
    for (int i = 0; i < n; i++) {
        memset(_t, 0, sizeof(_t));
        match(i);
    }
    //for (int i = 0; i < m; i++) {
    //    printf("lef[%d]:%d\n", i + 1, lef[i]+1);
    //}
}
//--------------------------------------------------------------- 

//tarjan求强连通---------------------------------------------- 
int pre[maxn], lowlink[maxn], sccno[maxn], dfs_clock, scc_cnt;
stack<int> S;

void dfs(int u) {
    pre[u] = lowlink[u] = ++dfs_clock;
    S.push(u);
    for (int i = 0; i < G2[u].size(); i++) {
        int v = G2[u][i];
        if (!pre[v]) {
            dfs(v);
            lowlink[u] = min(lowlink[u], lowlink[v]);
        }
        else if (!sccno[v]) {
            lowlink[u] = min(lowlink[u], pre[v]);
        }
    }
    if (lowlink[u] == pre[u]) {
        scc_cnt++;
        for (;;) {
            int x = S.top(); S.pop();
            sccno[x] = scc_cnt;
            if (x == u) break;
        }
    }
}

void find_scc(int n) {
    dfs_clock = scc_cnt = 0;
    memset(sccno, 0, sizeof(sccno));
    memset(pre, 0, sizeof(pre));
    for (int i = 0; i < n; i++) {
        if (!pre[i]) dfs(i);
    }
}
//--------------------------------------------------------------- 


int vis[maxn];
void solve() {
    //build
    memset(vis, 0, sizeof(vis));
    int tot_n = n;
    //构造完美匹配----------------------- 
    for (int i = 0; i < m; i++) {
        if (lef[i] == -1) {
            lef[i] = tot_n++;
        }
        vis[lef[i]] = 1;
    }
    int tot_m = m;
    for (int i = 0; i < tot_n; i++) {
        if (vis[i] == 0) lef[tot_m++] = i;
    }
    //-------------------
    
    //每一个王子心仪的公主的连边 
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < G[i].size(); j++) {
            int v = G[i][j];
            G2[i].push_back(v + tot_n);
        }
    }
    //每一个虚拟的王子与所有的公主的连边 
    for (int i = n; i < tot_n; i++) {
        for (int v = 0; v < m; v++) {
            G2[i].push_back(v + tot_n);
        }
    }
    //所有的王子与每一个虚拟公主连边 
    for (int i = m; i < tot_n; i++) {
        for (int v = 0; v < tot_n; v++) {
            G2[v].push_back(i+tot_n);
        }
    }
    //每一个公主与和她匹配的那个王子连边 
    for (int i = 0; i < tot_n; i++) {
        G2[i + tot_n].push_back(lef[i]);
    }

    //printf("tot_n:%d\n", tot_n);
    //for (int i = 0; i < tot_n * 2; i++) {
    //    printf("%d:", i + 1);
    //    for (int j = 0; j < G2[i].size(); j++) {
    //        int v = G2[i][j]; v++;
    //        printf("%d ", v);
    //    }
    //    printf("\n");
    //}

    //solve
    find_scc(tot_n*2);

    //for (int i = 0; i < tot_n * 2; i++) {
    //    printf("sccno[%d]:%d\n", i + 1, sccno[i]);
    //}

    //print
    for (int i = 0; i < n; i++) {
        vector<int> ans;
        for (int j = 0; j < G[i].size(); j++) {
            int v = G[i][j];
            if (sccno[i] == sccno[v + tot_n]) ans.push_back(v);
        }
        sort(ans.begin(), ans.end());
        out(ans.size());
        for (int i = 0; i < ans.size(); i++) {
            putchar(' ');
            out(ans[i] + 1);
        }
        putchar('\n');
    }
}

void init() {
    for (int i = 0; i < maxn; i++) G[i].clear(),G2[i].clear();
    memset(lef, -1, sizeof(lef));
}

int main() {
    int tc,kase=0;
    tc = scan();
    while (tc--) {
        init();
        n = scan(); m = scan();
        int ct,v;
        for (int i = 0; i < n; i++) {
            ct = scan();
            for (int j = 0; j < ct; j++) {
                v = scan(); v--;
                G[i].push_back(v);
            }
        }
        printf("Case #%d:\n", ++kase);
        BM();
        solve();
    }
    return 0;
}