poj 1904(强连通分量+输入输出外挂)

题目链接：http://poj.org/problem?id=1904

题意：有n个王子，每个王子都有k个喜欢的妹子，每个王子只能和喜欢的妹子结婚，大臣给出一个匹配表，每个王子都和一个妹子结婚，但是国王不满意，他要求大臣给他另一个表，每个王子可以和几个妹子结婚，按序号升序输出妹子的编号，这个表应满足所有的王子最终都有妹子和他结婚。

分析：很好的图论题，把强连通分量和完美匹配结合起来了，记得多校的时候看到类似的题目（hdu 4685），但是不会做，还以为是二分匹配=_=

首先建图，如果王子u喜欢妹子v，则建一条边u指向v(u,v)，对于大臣给出的初始完美匹配，如果王子u和妹子v结婚，则建一条边v指向u(v,u)，然后求强连通分量，

对于每个王子和妹子，如果他们都在同一个强连通分量内，则他们可以结婚。

为什么呢？因为每个王子只能和喜欢的妹子结婚，初始完美匹配中的丈夫和妻子之间有两条方向不同的边可以互达，则同一个强连通分量中的王子数和妹子数一定是相等的，若王子x可以和另外的一个妹子a结婚，妹子a的原配王子y肯定能找到另外一个妹子b结婚，因为如果找不到的话，则x和a必不在同一个强连通分量中。

所以一个王子可以和所有与他同一强连通分量的妹子结婚，而这不会导致同一强连通分量中的其他王子找不到妹子结婚。

好像很绕的样子@_@。。。。。大家在纸上画画图吧

建图的时候王子从1~n编号，妹子从n+1~2*n编号

这一题的数据量挺大的，光是输入输出就会消耗很多时间了，可以用输入输出外挂来加速读入和输出。

不加输入外挂9000+ms

加输入外挂8000+ms

加输入输出外挂500+ms

AC代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int N=4000+5;
const int M=200000+4000;
struct EDGE{
    int v,next;
}edge[M];
int first[N],low[N],dfn[N],sta[M],belong[N],ans[N];
bool instack[N];
int g,cnt,top,scc;

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;
}
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;
        }
    }
}
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');
}
int main()
{
    int n,i,u,v,k;
    while(scanf("%d",&n)!=EOF)
    {
        g=cnt=top=scc=0;
        memset(first,-1,sizeof(first));
        memset(dfn,0,sizeof(dfn));
        memset(instack,false,sizeof(instack));
        for(i=1;i<=n;i++)
        {
        //    scanf("%d",&k);
            k=Scan();
            while(k--)
            {
            //    scanf("%d",&v);
                v=Scan();
                AddEdge(i,v+n);      //王子i喜欢妹子v
            }
        }
        for(i=1;i<=n;i++)
        {
        //    scanf("%d",&v);
            v=Scan();
            AddEdge(v+n,i);       //王子i可以和妹子v结婚
        }

        for(i=1;i<=2*n;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])   //同一个强连通分量
                    ans[count++]=v-n;
            }
            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('
');
        }
    }
    return 0;
}