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

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

POJ1904加强版本

大致题意：

N个王子，N个妹子，每个王子喜欢N个妹子中的K个，

让求所有最大匹配每个王子解的集合。

题解：

问题主要在建边，设王子集合为X，妹纸集合为Y，

那么王子的选择为X->Y,

已知一组完美匹配方案X'->Y'，那么我们建反边Y'->X'（其实还是用到了二分匹配寻找增广路的思想），

模拟匈牙利算法，就可以明白，它是在保证了前一个结点有匹配的基础上，找到自己的匹配。

以上是POJ1904解法，

那么对于此题并不一定是完美匹配，

输入n跟m，然后就加入虚拟节点使二分图左右两边节点数一样=WA，加入虚拟节点是根据原图的二分匹配结果M决定的，左边还有x-M个没匹配，右边还有y-M个没匹配，所以这时应加入虚拟节点，使两边节点数均为x+y-M，这样才能保证那些原先没有匹配到的王子跟公主也在连通图中。比如两个王子，一个公主，这样的正解应该是两个王子都能娶该公主的。

//#include <bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int Scan()
{
    int res=0,ch,flag=0;
    if((ch=getchar())=='-')flag=1;
    else if(ch>='0'&&ch<='9')res=ch-'0';
    while((ch=getchar())>='0'&&ch<='9')res=res*10+ch-'0';
    return flag?-res:res;
}
void Out(int a)
{
    if(a>9)Out(a/10);
    putchar(a%10+'0');
}
#define INF 0x3f3f3f3f
#define bug cout<<"bug"<<endl
const int MAXN = 1e5+7;
struct node
{
    int v,next;
} edge[MAXN<<3];
int head[MAXN],index;
void add_edge(int u, int v)
{
    edge[index].v=v;
    edge[index].next=head[u];
    head[u]=index++;
}
int use[MAXN];
int link[MAXN],rlink[MAXN];
int N;
bool DFS(int u)
{
    for(int i=head[u]; i+1; i=edge[i].next)
    {
        int v=edge[i].v;
        if(!use[v])
        {
            use[v]=1;
            if(link[v]==-1 || DFS(link[v]))
            {
                link[v]=u;
                rlink[u]=v;
                return 1;
            }
        }
    }
    return 0;
}
int hungary(int Nu)
{
    int res=0;
    memset(link,-1,sizeof(link));
    memset(rlink,-1,sizeof(rlink));
    for(int i=1; i<=Nu; ++i)
    {
        memset(use,0,sizeof(use));
        if(DFS(i))res++;
    }
    return res;
}
int belong[MAXN],DFN[MAXN],low[MAXN],stack_[MAXN];
int cir,deep,top;
bool in_stack[MAXN];
void Tarjan(int u)
{
    int p;
    DFN[u]=low[u]=++deep;
    in_stack[u]=1;
    stack_[top++]=u;
    for(int i=head[u]; i+1; i=edge[i].next)
    {
        int v=edge[i].v;
        if(!DFN[v])
        {
            Tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(in_stack[v])
            low[u]=min(low[u],DFN[v]);
    }
    if(DFN[u]==low[u])
    {
        cir++;
        do
        {
            p=stack_[--top];
            in_stack[p]=0;
            belong[p]=cir;
        }
        while(p!=u);
    }
}
int ans[MAXN];
int main()
{
    int T,n,m,k;
    T=Scan();
    int cas=1;
    while(T--)
    {
        memset(head,-1,sizeof(head));
        memset(DFN,0,sizeof(DFN));
        deep=index=top=cir=0;
        n=Scan(),m=Scan();
        N=max(n,m);
        for(int i=1; i<=n; ++i)
        {
            k=Scan();
            for(int j=0; j<k; ++j)
            {
                int a=Scan();
                add_edge(i,a+N);
            }
        }
        hungary(N);
        int all=N<<1;
        for(int i=1; i<=N; ++i)
            if(rlink[i]==-1)
            {
                all++;
                for(int j=1; j<=N; ++j)
                    add_edge(j,all);
                link[all]=i;
                rlink[i]=all;
            }
        for(int i=N+1; i<=N<<1; ++i)
            if(link[i]==-1)
            {
                all++;
                for(int j=N+1; j<=N<<1; ++j)
                    add_edge(all,j);
                rlink[all]=i;
                link[i]=all;
            }
        for(int i=1; i<=all; ++i)
            if(rlink[i])
            add_edge(rlink[i],i);

        /*
        for(int i=n+1; i<=m; ++i)
            for(int j=1; j<=m; ++j)
            add_edge(i,j+N);
        for(int i=m+1; i<=n; ++i)
            for(int j=1; j<=n; ++j)
            add_edge(j,i+N);

        for(int i=N+1; i<=N<<1; ++i)
            if(link[i]!=-1)
            {
                add_edge(i,link[i]);
                // cout<<i<<" - "<<link[i]<<endl;
            }*/

        for(int i=1; i<=N<<1; ++i)
            if(!DFN[i])
                Tarjan(i);
        printf("Case #%d:\n",cas++);
        for(int i=1; i<=n; ++i)
        {
            int temp=0;
            for(int j=head[i]; j+1; j=edge[j].next)
            {
                int v=edge[j].v;
                if(v-N<=m && belong[i]==belong[v])
                    ans[temp++]=v-N;
            }
            Out(temp);
            sort(ans,ans+temp);
            for(int j=0; j<temp; ++j)
                putchar(' '),Out(ans[j]);
            putchar('\n');
        }
    }
    return 0;
}

/*
2
4 4
2 1 2
2 1 2
2 2 3
2 3 4
1 2
2 1 2

2
4 4
2 1 2
2 1 2
2 2 3
2 3 4


3
3 3
1 1
0
1 3

*/