hdu 4685(强连通分量+二分图的完美匹配)

传送门:Problem 4685

https://www.cnblogs.com/violet-acmer/p/9739990.html

参考资料：

　　[1]:二分图的最大匹配、完美匹配和匈牙利算法

　　[2]:http://www.cnblogs.com/frog112111/p/3387173.html

题意：

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

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

分析：

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

　　所以只要求出完美匹配之后，就和poj 1904的做法就完全相同了。

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

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

　　比如：

　　　　   2 2

　　    1 1

　　    1 1

　　输出的答案是：

　　　　　　　　1 1

1 1

　　而不是  　　

　　　　　　　　1 1

　　　　　　　　 0

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

　　求完美匹配：

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

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

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

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

AC代码：

 #include<iostream>
 #include<cstdio>
 #include<vector>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 #define pb push_back
 #define mem(a,b) memset(a,b,sizeof a)
 const int maxn=+++;

 int n,m;
 //===========匈牙利===========
 struct Node
 {
     int matchM[maxn];
     int matchW[maxn];
     bool check[maxn];
     vector<int >edge[maxn];
     void Init()
     {
         mem(matchM,-);
         mem(matchW,-);
         for(int i=;i < maxn;++i)
             edge[i].clear();
     }
     void addEdge(int u,int v){
         edge[u].pb(v);
     }
     bool Dfs(int u)
     {
         for(int i=;i < edge[u].size();++i)
         {
             int to=edge[u][i];
             if(!check[to])
             {
                 check[to]=true;
                 if(matchW[to] == - || Dfs(matchW[to]))
                 {
                     matchW[to]=u;
                     matchM[u]=to;
                     return true;
                 }
             }
         }
         return false;
     }
     void Hungarian()
     {
         for(int i=;i <= n;++i)
         {
             mem(check,false);
             Dfs(i);
         }
     }
 }_match;
 //============================
 //============SCC=============
 int scc[maxn];
 bool vis[maxn];
 vector<int >vs;
 vector<int >edge[maxn],redge[maxn];
 void addEdge(int u,int v)
 {
     edge[u].pb(v);
     redge[v].pb(u);
 }
 void Dfs(int u)
 {
     vis[u]=true;
     for(int i=;i < edge[u].size();++i)
     {
         int to=edge[u][i];
         if(!vis[to])
             Dfs(to);
     }
     vs.pb(u);
 }
 void rDfs(int u,int sccId)
 {
     scc[u]=sccId;
     vis[u]=true;
     for(int i=;i < redge[u].size();++i)
     {
         int to=redge[u][i];
         if(!vis[to])
             rDfs(to,sccId);
     }
 }
 void Scc()
 {
     mem(vis,false);
     vs.clear();
     for(int i=;i <= n;++i)
         if(!vis[i])
             Dfs(i);
     mem(vis,false);
     int sccId=;
     for(int i=vs.size()-;i >= ;--i)
     {
         int to=vs[i];
         if(!vis[to])
             rDfs(to,++sccId);
     }
 }
 //============================
 void Init()
 {
     _match.Init();
     for(int i=;i < maxn;++i)
         edge[i].clear(),redge[i].clear();
 }
 int main()
 {
     int T;
     scanf("%d",&T);
     for(int kase=;kase <= T;++kase)
     {
         Init();
         scanf("%d%d",&n,&m);
         for(int i=;i <= n;++i)
         {
             int k;
             scanf("%d",&k);
             while(k--)
             {
                 int v;
                 scanf("%d",&v);
                 addEdge(i,v+n);
                 _match.addEdge(i,v+n);
             }
         }
         _match.Hungarian();//匈牙利算法求最大匹配
         int all=n+m;
         for(int i=;i <= n;++i)
         {
             if(_match.matchM[i] == -)//为剩余王子匹配虚拟公主
             {
                 all++;
                 for(int j=;j <= n;++j)//所有王子都喜欢该虚拟公主
                     addEdge(j,all);
                 _match.matchM[i]=all;
                 _match.matchW[all]=i;
             }
         }
         for(int i=n+;i <= n+m;++i)
         {
             if(_match.matchW[i] == -)//为剩余公主匹配虚拟王子
             {
                 all++;
                 for(int j=n+;j <= n+m;++j)//该虚拟王子喜欢所有公主
                     addEdge(all,j);
                 _match.matchM[all]=i;
                 _match.matchW[i]=all;
             }
         }
         for(int i=;i <= all;++i)
             if(_match.matchM[i] != -)//所有与王子匹配的公主建一条边连向王子
                 addEdge(_match.matchM[i],i);
         Scc();//求强连通分量
         printf("Case #%d:\n",kase);
         for(int i=;i <= n;++i)
         {
             int res=;
             int ans[maxn];
             for(int j=;j < edge[i].size();++j)
             {
                 int to=edge[i][j];
                 if(scc[i] == scc[to] && to <= m+n)//剔除掉虚拟的公主
                     ans[res++]=to-n;
             }
             sort(ans,ans+res);
             printf("%d",res);
             for(int i=;i < res;++i)
                 printf(" %d",ans[i]);
             printf("\n");
         }
     }
 }

Kosaraju算法