HUD -- 3081 Marriage Match II（最大流+二分+并查集）

题目大意：

有n个女孩n个男孩玩过家家，给出m组女孩男孩不会吵架的关系，给出f组女孩和女孩是好朋友的关系，朋友之间的关系是可以传递的，女孩选择男孩配对保证女孩及女孩的朋友都不会和这个男孩吵架，每一轮游戏，女孩 不能选择相同的男孩，问最多能进行几轮游戏。

思路分析：

①：女孩的朋友关系是可以相互出传递的，所以利用并查集的方法，只要两个女孩是朋友，那么只要她们其中一个人可以选择一个男孩，那么另一个人也可以选择这个男孩；

②：最少进行0轮游戏，最多进行n游戏，可以用二分的方法确定游戏的轮数；

③：建图，首先设立一个超级源点s，连向女孩，权值为二分找出的可以游戏的次数，其次设立一个汇点，让每个男孩连向汇点，权值也二分和找出的可以游戏的次数，最后让女孩连向男孩，权值为1，因为一个女生对于一个可以选择的男生只能选择一次；

代码实现：

#include<cstdio>
#include<cstring>
#include<queue>
#include<iostream>
using namespace std;
const int N=210;
const int M=20410;
const int INF=0x3f3f3f3f;
int n,m,f,s,t,top,head[N],gap[N],cur[N],pre[N],dis[N],line[110][110],fa[110];

struct Edge{
    int to,next,flow;
}edge[M];

int Find(int a){
    return fa[a]==a?a:fa[a]=Find(fa[a]);
}

void Merge(int a,int b){
    int x=Find(a),y=Find(b);
    if(x==y) return;
    fa[y]=x;
}

void Addedge(int from,int to,int flow){
    edge[top].to=to,edge[top].next=head[from],edge[top].flow=flow,head[from]=top++;
    edge[top].to=from,edge[top].next=head[to],edge[top].flow=0,head[to]=top++;
}

void Bfs(){
    queue<int> q;
    memset(gap,0,sizeof(gap));
    memset(dis,-1,sizeof(dis));
    gap[0]=1,dis[t]=0;
    q.push(t);
    while(!q.empty()){
        int u=q.front();
        q.pop();
        for(int i=head[u];i+1;i=edge[i].next){
            if(dis[edge[i].to]==-1){
                dis[edge[i].to]=dis[u]+1;
                gap[dis[edge[i].to]]++;
                q.push(edge[i].to);
            }
        }
    }
}

int Sap(){
    Bfs();
    memset(pre,-1,sizeof(pre));
    for(int i=0;i<=t;++i) cur[i]=head[i];
    int u=s,i,cur_flow,max_flow=0,neck,tmp;
    while(dis[s]<=t){
        if(u==t){
            cur_flow=INF;
            for(int i=s;i!=t;i=edge[cur[i]].to){
                if(cur_flow>edge[cur[i]].flow){
                    neck=i;
                    cur_flow=edge[cur[i]].flow;
                }
            }
            for(int i=s;i!=t;i=edge[cur[i]].to){
                tmp=cur[i];
                edge[tmp].flow-=cur_flow;
                edge[tmp^1].flow+=cur_flow;
            }
            max_flow+=cur_flow;
            u=neck;
        }
        int i;
        for(i=cur[u];i!=-1;i=edge[i].next)
            if(edge[i].flow&&dis[u]==dis[edge[i].to]+1) break;
        if(i!=-1){
            cur[u]=i;
            pre[edge[i].to]=u;
            u=edge[i].to;
        }else{
            if(--gap[dis[u]]==0) break;
            cur[u]=head[u];
            int mindis=t;
            for(i=head[u];i!=-1;i=edge[i].next){
                if(edge[i].flow&&mindis>dis[edge[i].to])
                    mindis=dis[edge[i].to];
            }
            dis[u]=mindis+1;
            gap[dis[u]]++;
            if(u!=s) u=pre[u];
        }
    }
    return max_flow;
}

int main(){
    int T,a,b;
    scanf("%d",&T);
    while(T--){
        memset(line,0,sizeof(line));
        for(int i=1;i<=n;++i) fa[i]=i;
        scanf("%d%d%d",&n,&m,&f);
        s=0,t=n*2+1;
        for(int i=0;i<m;++i){
            scanf("%d%d",&a,&b);
            line[a][b]=1;
        }
        for(int i=0;i<f;++i){
            scanf("%d%d",&a,&b);
            Merge(a,b);
            for(int i=1;i<=n;++i)
                if(line[a][i]||line[b][i]) line[a][i]=1,line[b][i]=1;
        }
        int low=0,high=n,mid;
        while(low<=high){
            mid=(low+high)/2;
            memset(head,-1,sizeof(head));
            top=0;
            for(int i=1;i<=n;++i){
                Addedge(s,i,mid);
                Addedge(n+i,t,mid);
                for(int j=1;j<=n;++j)
                    if(line[i][j]) Addedge(i,j+n,1);
            }
            int res=Sap();
            if(mid*n==res) low=mid+1;
            else high=mid-1;
        }
        printf("%d\n",high);
    }
}