HDU 4685 Prince and Princess （二分图匹配 + 强连通分量）

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

 

题意：有n个王子和m个公主，每个王子有自己喜欢的公主，王子只跟自己喜欢的公主配对，公主可以和任何王子配对，输出王子可能的配偶，需要保证王子与这些配偶中的任意一个结婚，都不会影响到剩余的王子的配对数

 

思路：因为王子和公主数目会不同，所以会有人无法配对，所以先跑一遍二分图匹配求出最大匹配数res，然后左边虚拟m -  res个点和右边所有点连边，右边再虚拟n - res个点和左边所有点连边，这样就可以构成 n + m - res 的完美匹配，然后对于左边的某点i，把它右边匹配的点j及与i相连的点ki连边，这样对于匹配点j如果它和ki在同一个强连通分量内，那么这两点就可以互换并且不影响匹配数

 

 

#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <utility>
#include <functional>
#include <algorithm>
#include <string>
#include <queue>
#include <cctype>
#include <set>
#pragma comment(linker, "/STACK:1024000000,1024000000")

using namespace std;

const int MAXN = 1010;
const int MAXM = 500010;

int uN, vN;
int g[MAXN][MAXN];
int linker[MAXN];
bool used[MAXN];

struct Edge
{
    int to, next;
} edge[MAXM];

int head[MAXN], tot;
int Low[MAXN], DFN[MAXN], Stack[MAXN], Belong[MAXN];
int Index, top;
int scc;

bool Instack[MAXN];
int num[MAXN];

void addedge(int u, int v)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}

void Tarjan(int u)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    for (int i = head[u]; i != -1; i = edge[i].next)
    {
        v = edge[i].to;
        if ( !DFN[v] )
        {
            Tarjan(v);
            if ( Low[u] > Low[v] )Low[u] = Low[v];
        }
        else if (Instack[v] && Low[u] > DFN[v])
            Low[u] = DFN[v];
    }
    if (Low[u] == DFN[u])
    {
        scc++;
        do
        {
            v = Stack[--top];
            Instack[v] = false;
            Belong[v] = scc;
            num[scc]++;
        }
        while (v != u);
    }
}

void solve(int N)
{
    memset(DFN, 0, sizeof(DFN));
    memset(Instack, false, sizeof(Instack));
    memset(num, 0, sizeof(num));
    Index = scc = top = 0;
    for (int i = 1; i <= N; i++)
        if (!DFN[i])
            Tarjan(i);
}

void init()
{
    tot = 0;
    memset(head, -1, sizeof(head));
}

bool dfs(int u)
{
    for (int v = 1; v <= vN; v++)
        if (g[u][v] && !used[v])
        {
            used[v] = true;
            if (linker[v] == -1 || dfs(linker[v]))
            {
                linker[v] = u;
                return true;
            }
        }
    return false;
}

int hungary()
{
    int res = 0;
    memset(linker, -1, sizeof(linker));
    for (int u = 1; u <= uN; u++)
    {
        memset(used, false, sizeof(used));
        if (dfs(u))
            res++;
    }
    return res;
}

int lk[MAXN];
vector <int> ans;

int main()
{
    int t;
    scanf("%d", &t);
    for (int ca = 1; ca <= t; ca++)
    {
        int n, m;
        scanf("%d%d", &n, &m);
        uN = n, vN = m;
        memset(g, 0, sizeof(g));
        for (int i = 1; i <= n; i++)
        {
            int num;
            scanf("%d", &num);
            for (int j = 0; j < num; j++)
            {
                int id;
                scanf("%d", &id);
                g[i][id] = 1;
            }
        }
        int res = hungary();
        //cout << res << endl;
        uN = vN = n + m - res;
        for (int i = n + 1; i <= uN; i++)
            for (int j = 1; j <= vN; j++)
                g[i][j] = 1;
        for (int i = 1; i <= uN; i++)
            for (int j = m + 1; j <= vN; j++)
                g[i][j] = 1;

        init();
        hungary();
        for (int i = 1; i <= vN; i++)
            if (linker[i] != -1)
                lk[linker[i]] = i;
        for (int i = 1; i <= uN; i++)
            for (int j = 1; j <= vN; j++)
                if (g[i][j] && j != lk[i])
                    addedge(lk[i], j);
        solve(uN);

        printf("Case #%d:\n", ca);
        for (int i = 1; i <= n; i++)
        {
            ans.clear();
            for (int j = 1; j <= m; j++)
                if (g[i][j] && Belong[j] == Belong[lk[i]])
                    ans.push_back(j);
            printf("%d", ans.size());
            for (int i = 0; i < ans.size(); i++)
                printf(" %d", ans[i]);
            printf("\n");
        }
    }
    return 0;
}