hdu 4685(强连通分量+二分图)

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

题意：n个王子和m个公主，王子只能和他喜欢的公主结婚，公主可以和所有的王子结婚，输出所有王子可能的结婚对象，

必须保证王子与任意这些对象中的一个结婚，都不会影响到剩余的王子的配对数，也就是不能让剩余的王子中突然有一个人没婚可结了。

分析：这题是poj 1904的加强版，poj 1904的王子和公主数是相等的，这里可以不等，且poj 1904给出了一个初始完美匹配，但是这题就要自己求。

所以只要求出完美匹配之后，就和poj 1904的做法就完全相同了，这里就不在赘述了，可以参考：http://www.cnblogs.com/frog112111/p/3384261.html

那么怎么求出完美匹配呢？一开始我用多重匹配的匈牙利算法来做，但是怎么做都不对.......看了题解才恍然大悟=_=

先说几个坑，这题有点奇怪，就是所有王子都可以争着和同一个公主结婚，只要该王子喜欢该公主，感觉公主有点悲哀呀........

比如：2 2

        1 1

        1 1

      

输出的答案是：1 1   而不是  1 1

                    1 1             0        

这里就是和poj 1904有点不一样的地方，坑了我好久.........

求完美匹配：

先对原图用匈牙利算法做一遍二分图匹配，但是还有可能剩余一些人还没匹配，只要虚拟出一些节点来匹配剩余的点就行了

假设王子有剩下的，那么每个剩下的王子就连一个虚拟的公主，这个公主被所有的王子都喜欢。

假设公主有剩下的，那么每个剩下的公主就连一个虚拟的王子，这个王子喜欢所有的公主

这样就构成完美匹配了，接下来就是和poj 1904一样了。

注意：虽然n和m才500，但是数组要开到2000才能过，可能是剩余太多顶点没匹配，所以要虚拟出比较多的顶点吧，我只开到1500，wa到死=_=

还有就是一些细节没处理好也贡献了好多wa，做了一天.........快奔溃了，最后参考别人的代码改来改去才AC，好艰辛，不过最终能过也算安慰了

果然想问题还是不够周全，不够细心

大三了都，哎，弱成一坨翔了~

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=2000;
const int M=1000000+3000;
struct EDGE{
    int v,next;
}edge[M];
int first[N],low[N],dfn[N],sta[M],belong[N];
int ans[N],match[N],flag[N];
bool instack[N],vis[N];
int n,m,g,cnt,top,scc,maxn;
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');
}
void AddEdge(int u,int v)
{
    edge[g].v=v;
    edge[g].next=first[u];
    first[u]=g++;
}
int min(int a,int b)
{
    return a<b?a:b;
}
int max(int a,int b)
{
    return a>b?a:b;
}
void init()
{
    g=cnt=top=scc=0;
    memset(first,-1,sizeof(first));
    memset(dfn,0,sizeof(dfn));
    memset(instack,false,sizeof(instack));
    memset(flag,0,sizeof(flag));
    //scanf("%d%d",&n,&m);
    n=Scan();
    m=Scan();
    maxn=max(n,m);    //王子和公主数可能不同，为了建图方便去较大者，王子编号1--maxn,公主编号maxn+1--2*maxn
}
bool dfs(int u)
{
    int i,v;
    for(i=first[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].v;
        if(!vis[v])
        {
            vis[v]=true;
            if(match[v]==0||dfs(match[v]))
            {
                match[v]=u;
                flag[u]=v;
                return true;
            }
        }
    }
    return false;
}
void xiong()    //二分匹配
{
    int i;
    memset(match,0,sizeof(match));
    for(i=1;i<=maxn;i++)
    {
        memset(vis,false,sizeof(vis));
        dfs(i);
    }
}
void Tarjan(int u)     //求强连通分量
{
    int i,v;
    low[u]=dfn[u]=++cnt;
    sta[++top]=u;
    instack[u]=true;
    for(i=first[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].v;
        if(!dfn[v])
        {
            Tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(instack[v])
            low[u]=min(low[u],dfn[v]);
    }
    if(low[u]==dfn[u])
    {
        scc++;
        while(1)
        {
            v=sta[top--];
            instack[v]=false;
            belong[v]=scc;
            if(u==v)
                break;
        }
    }
}
void build()
{
    int i,k,v,j;
    for(i=1;i<=n;i++)
    {
    //    scanf("%d",&k);
        k=Scan();
        while(k--)
        {
        //    scanf("%d",&v);
            v=Scan();
            AddEdge(i,v+maxn);    //王子和喜欢的公主之间连边
        }
    }

    xiong();   //做一次二分匹配

    int all=2*maxn;
    for(i=1;i<=maxn;i++)    //为剩余王子匹配虚拟公主
    {
        if(!flag[i])
        {
            all++;
            for(j=1;j<=maxn;j++)  //所有王子都喜欢该虚拟公主
                AddEdge(j,all);
            match[all]=i;
            flag[i]=all;
        }
    }

    for(i=maxn+1;i<=2*maxn;i++)    //为剩余公主匹配虚拟王子
    {
        if(!match[i])
        {
            all++;
            for(j=maxn+1;j<=2*maxn;j++)   //该虚拟王子喜欢所有公主
                AddEdge(all,j);
            flag[all]=i;
            match[i]=all;
        }
    }
    for(i=1;i<=all;i++)    //所有与王子匹配的公主建一条边连向王子
    {
        if(flag[i])
            AddEdge(flag[i],i);
    }
}
void solve()
{
    int i,u,v;
    for(i=1;i<=maxn;i++)   //求强连通分量
        if(!dfn[i])
            Tarjan(i);

    for(u=1;u<=n;u++)  //枚举所有王子
    {
        int count=0;
        for(i=first[u];i!=-1;i=edge[i].next)
        {
            v=edge[i].v;
            if(belong[u]==belong[v])    //王子与公主同在一个强连通分量
            {
                if(v-maxn>m)
                    continue;
                ans[count++]=v-maxn;
            }
        }
        sort(ans,ans+count);
    //    printf("%d",count);
        Out(count);
        for(i=0;i<count;i++)      //输出
        {
            //printf(" %d",ans[i]);
            putchar(' ');
            Out(ans[i]);
        }
    //    printf("
");
        putchar('
');
    }
}
int main()
{
    int t,cas;;
//    scanf("%d",&t);
    t=Scan();
    for(cas=1;cas<=t;cas++)
    {
        init();
        build();
        printf("Case #%d:
",cas);
        solve();
    }
    return 0;
}