hdu 4685 Prince and Princess(完美匹配+SCC缩点)

题目大意：n个王子与m个公主进行匹配，要求给出每个王子可以匹配的公主列表，列表中的公主应当满足：与该王子匹配后，最大匹配数目能够保持不变。

分析：此题是poj 1904的加强版。虽然题意有所不同，但仍然可以参考那题的建图方式。首先，需要搞清楚：

为什么可以利用完美匹配来建图，或者说为什么这样建图是正确的？

设王子Xi与公主Yi匹配，王子Xj与公主Yj匹配，同时Xi还喜欢Yj，问题的关键就是当满足什么条件时，Xi与Yj匹配能够使得总匹配数不变。

如果Xi与Yj进行匹配，而王子Xj又喜欢Yi，那么让Xj与Yi进行匹配就好了，总匹配数不变；如果Xj不喜欢Yi，那么就需要拆掉其他的匹配，直到找到一个王子Xk，Xk喜欢Yi，而Xj喜欢Yk，将Xk与Yi匹配，而Xj与Yk匹配。

将上述文字换一种表述就是：Xi与Yi可以互达，Xj与Yj可以互达，且Xi到Yj有一条有向边。如果存在Xk，使得Xi->Yj->Xj->Yk->Xk->Yi（->Xi），那么Xi与Yj匹配能够使得总匹配数不变。此时，Yj可达Yi，Yi可达Yj，Yi与Yj属于一个SCC。

明白了这个，再来看这题。此题并未给出完美匹配，需要去求，注意到求出来的匹配不一定是完美匹配。而上述模型是基于完美匹配建立起来的。这就需要去构造一个完美匹配。

如何构造？

对于每一个未匹配的王子，可以发现如果使其与其喜欢的公主进行匹配，总匹配数是不会变化的。因此，他所喜欢的每一个公主都是可以和他匹配的。由上面的分析可知，这些公主属于一个SCC。于是，可以虚构一个公主，使得其与这些公主属于一个SCC。这样就可以通过求SCC得到列表。

对于每一个未匹配的公主，如果有王子喜欢她，同样可以让该王子与其匹配，而总匹配数不变。此时，可以虚构一个王子，让该王子与该未匹配的公主匹配后，该公主与喜欢她的王子的喜欢的公主属于一个SCC。

具体的做法是：

一开始求一次最大匹配。

对于未匹配的王子Xi，虚构一个公主与其匹配，同时让该公主被所有王子喜欢。这样该公主可以通过Xi，到达Xi喜欢的公主，而Xi喜欢的公主又可以通过与其匹配的王子到达该公主。即属于一个SCC。

对于未匹配的公主Yi，虚构一个王子与其匹配，同时让该王子喜欢所有的公主。这样喜欢Yi的王子他所喜欢的其他公主，可以通过与其匹配的王子到达Yi，而Yi又可以通过该虚构的王子到达每个公主。即属于一个SCC。

在具体代码实现上述过程的时候，考虑数据范围同时为了方便，求匹配的时候使用邻接矩阵存图（可以方便地虚构王子和公主并建立关系）

为了方便，第一次求出匹配并虚构出王子和公主后，并未让未匹配的王子(或公主)与虚拟的公主(或王子)匹配，而是再求一次匹配，得到一个完美匹配。在该匹配的基础上，重新再建立一个图：将与王子Xi匹配的公主与Xi喜欢的其他公主连一条有向边。这样只需对所有公主求SCC就好了。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<stack>
#include<vector>
using namespace std;
#define N 1005
bool Map[N][N],T[N];
int Left[N],M,Right[N],low[N],dfn[N],sccno[N],dfs_clock,scc_cnt,cnt,head[N];
stack<int> S;

struct Edge{
    int v,next;
}edge[500005];

inline void add(int u,int v){
    edge[cnt].v=v;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}

int match(int u){
    for(int v=1;v<=M;++v)
        if(Map[u][v]&&!T[v]){
            T[v]=1;
            if(!Left[v]||match(Left[v])){
                Left[v]=u;
                Right[u]=v;
                return 1;
            }
        }
    return 0;
}

void dfs(int u){
    dfn[u]=low[u]=++dfs_clock;
    S.push(u);
    for(int i=head[u];~i;i=edge[i].next){
        int v=edge[i].v;
        if(!dfn[v]){
            dfs(v);
            low[u]=min(low[u],low[v]);
        }else if(!sccno[v]) low[u]=min(low[u],dfn[v]);
    }
    if(low[u]==dfn[u]){
        ++scc_cnt;
        for(;;){
            int x=S.top();S.pop();
            sccno[x]=scc_cnt;
            if(x==u) break;
        }
    }
}

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

int ans[N];

int main()
{
    int ca,t,i,j,k,x,p,n,m;
    scanf("%d",&t);
    for(ca=1;ca<=t;++ca){
        scanf("%d%d",&n,&m);
        memset(Map,0,sizeof(Map));
        memset(head,-1,sizeof(head));
        cnt=0;
        for(i=1;i<=n;++i){
            scanf("%d",&k);
            while(k--){
                scanf("%d",&x);
                Map[i][x]=1;
            }
        }
        memset(Left,0,sizeof(Left));
        memset(Right,0,sizeof(Right));
        p=0,M=m;
        for(i=1;i<=n;++i){
            for(j=1;j<=m;++j) T[j]=0;
            p+=match(i);
        }
        M=m+n-p;
        for(i=n+1;i<=M;++i)
            for(j=1;j<=M;++j) Map[i][j]=1;
        for(j=m+1;j<=M;++j)
            for(i=1;i<=M;++i) Map[i][j]=1;

        memset(Left,0,sizeof(Left));
        memset(Right,0,sizeof(Right));
        for(i=1;i<=M;++i){
            for(j=1;j<=M;++j) T[j]=0;
            match(i);
        }

        for(i=1;i<=M;++i)
            for(j=1;j<=M;++j)
                if(Right[i]!=j&&Map[i][j]) add(Right[i],j);

        find_scc(M);

        printf("Case #%d:\n",ca);
        for(i=1;i<=n;++i){
            int tot=0;
            for(j=1;j<=m;++j)
                if(Map[i][j]&&sccno[Right[i]]==sccno[j])
                    ans[tot++]=j;
            printf("%d",tot);
            for(j=0;j<tot;++j) printf(" %d",ans[j]);
            puts("");
        }
    }
    return 0;
}