hdu3081 Marriage Match II(二分+并查集+最大流)

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

题意：

n个女生与n个男生配对，每个女生只能配对某些男生，有些女生相互是朋友，每个女生也可以跟她朋友能配对的男生配对。

每次配对，每个女生都要跟不同的男生配对且每个女生都能配到对。问最多能配对几轮。

思路：

这道题乍看之下好像是二分匹配，但仔细一想是不太一样的。考虑用网络流做，首先女生可以与她朋友能配对的男生配对，这样需要用并查集保存他们可以配对的关系，这一点应该不难想到。接下来就是建图了，每个女生与可以配对的男生(包括朋友的可配对的男生)之间建边，容量为 1。 这样需要考虑的就是源点和女生、男生和汇点之间该如何建边了。

本来考虑到n个女生和n个男生不重复完全配对最多只能进行n轮，想到可以将源点和女生、男生和汇点之间的容量赋为n，求出最大流。但是发现这样是不行的，如果有女生或者男生无法配对到，即一轮都无法进行，这样得到的答案就不对了。为了保证每一轮所有女生和男生都能匹配到，我们需要二分源点和女生、男生和汇点之间的容量k，并且需要保证满流。找到最大的满足条件的k就是答案。

解法的正确性可以用数学归纳法证明，简单来说，当k=1时，转化为一个二分匹配，如果满流，就说明可以进行一轮。当k-1轮可以实现时（k-1满流），如果容量为k时满流，说明也可以实现k轮。这样就证明了正确性。

由这个解法我们也可以想到用二分匹配的方法来解决：进行二分图的最大匹配，在匹配完成后判断匹配数是否等于n，不是的话说明GAME OVER 求得答案，是的话说明游戏能完成，然后进行删边操作，再继续匹配，直到匹配数<n为止。

下面给出二分最大流的代码：

 #include<iostream>
 #include<cstdio>
 #include<cmath>
 #include<cstring>

 using namespace std;
 const int MAXN = ;
 const int MAXM = ;
 const int INF = 0x3f3f3f3f;
 struct Edge
 {
     int to, next, cap, flow;
 }edge[MAXM];
 int tol;
 int head[MAXN];
 void init()
 {
     tol = ;
     memset(head, -, sizeof(head));
 }
 void addedge(int u, int v, int w, int rw=)
 {
     edge[tol].to = v; edge[tol].cap = w; edge[tol].flow = ;
     edge[tol].next = head[u]; head[u] = tol++;
     edge[tol].to = u; edge[tol].cap = rw; edge[tol].flow = ;
     edge[tol].next = head[v]; head[v] = tol++;
 }
 int Q[MAXN];
 int dep[MAXN], cur[MAXN], sta[MAXN];
 bool bfs(int s, int t, int n)
 {
     int front = , tail = ;
     memset(dep, -, sizeof(dep[])*(n+));
     dep[s] = ;
     Q[tail++] = s;
     while(front < tail)
     {
         int u = Q[front++];
         for(int i = head[u]; i != -; i = edge[i].next)
         {
             int v = edge[i].to;
             if(edge[i].cap > edge[i].flow && dep[v] == -)                         {
                 dep[v] = dep[u] + ;
                 if(v == t) return true;
                 Q[tail++] = v;
             }
         }
     }
     return false;
 }
 int dinic(int s, int t, int n) {
     int maxflow = ;
     while(bfs(s, t, n)) {
         for(int i = ; i < n; i++) cur[i] = head[i];
         int u = s, tail = ;
         while(cur[s] != -)
         {
             if(u == t)
             {
                 int tp = INF;
                 for(int i = tail-; i >= ; i--)
                     tp = min(tp, edge[sta[i]].cap-edge[sta[i]].flow);
                 maxflow+=tp;
                 for(int i = tail-; i >= ; i--) {
                     edge[sta[i]].flow+=tp;
                     edge[sta[i]^].flow-=tp;
                     if(edge[sta[i]].cap-edge[sta[i]].flow==)
                         tail = i;
                 }
                 u = edge[sta[tail]^].to;
             }
             else
                 if(cur[u] != - && edge[cur[u]].cap > edge[cur[u]].flow && dep[u] +  == dep[edge[cur[u]].to])
                 {
                     sta[tail++] = cur[u];
                     u = edge[cur[u]].to;
                 }
                 else
                 {
                     while(u != s && cur[u] == -)
                         u = edge[sta[--tail]^].to;
                     cur[u] = edge[cur[u]].next;
                 }
         }
     }
     return maxflow;
 }
 int n,m,f;
 int fa[MAXN];
 int map[][];

 int find(int x)
 {
     return fa[x]==x?x:fa[x]=find(fa[x]);
 }

 void unio(int x,int y)
 {
     int a=find(x),b=find(y);
     if(a!=b)
         fa[a]=b;
 }

 void build(int k)
 {
     init();
     for(int i=;i<=n;++i)
     {
         addedge(,i,k);
         addedge(i+n,*n+,k);
     }
     for(int i=;i<=n;++i)
         for(int j=;j<=n;++j)
             if(map[i][j])
                 addedge(i,n+j,);
 }
 int main()
 {
     int t;
     scanf("%d",&t);
     while(t--)
     {
         scanf("%d%d%d",&n,&m,&f);
         for(int i=;i<=n;++i)
             fa[i]=i;
         memset(map,,sizeof(map));
         int a,b;
         for(int i=;i<=m;++i)
         {
             scanf("%d%d",&a,&b);
             map[a][b]=;
         }
         for(int i=;i<=f;++i)
         {
             scanf("%d%d",&a,&b);
             unio(a,b);
         }
         for(int i=;i<=n;++i)
             for(int j=;j<=n;++j)
                 if(find(i)==find(j))
                     for(int k=;k<=n;++k)
                         if(map[i][k])
                             map[j][k]=;
         int s=,t=n,ans;
         while(s<=t)
         {
             int mid=(s+t)/;
             build(mid);
             if(mid*n==dinic(,*n+,*n+))
             {
                 ans=mid;
                 s=mid+;
             }
             else
                 t=mid-;
         }
         cout<<ans<<endl;
     }
     return ;
 }