HDU3081 3081 Marriage Match II(中等，好题)（[二分最大流]+并查集）

题意：n个女孩，要和n个男孩配对，当每一个女孩都配对成功的时候，进入下一轮。每次都是女孩选择男孩，同时还告诉你哪些女孩和男孩之间没有吵过架，配对的原则是她们之间没有吵过架，同时女孩选择的男孩也不能和她的另外的闺蜜有过吵架。问最多可以进行几轮游戏。
思路：关键是建图，从女孩到男孩连一条边权是1 的边，在附加一个源点，源点到每一个女孩连一条权k的边，每个男孩连一条权k的边到汇点。然后跑最大流，判断是不是等于n*k，对于k的选择就是二分枚举。然后对于女孩的关系，用并查集进行维护

#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
using namespace std;
#define cl(a,b) memset(a,b,sizeof(a))
const int maxn=505;
const int inf=1<<28;
const int nv=505;
const int ne=500000;

struct isap{//最大流的板子
    int n,size;
    int head[nv];
    int dis[nv],gap[nv],cur[nv],pre[nv];
    int maxflow;

    struct edge{
        int v,w,next;
        edge(){}
        edge(int _v,int _w,int _next):v(_v),w(_w),next(_next){}
    }E[ne];

    void init(int n){
        this->n=n,size=0;
        cl(head,-1);
    }
    void insert(int u,int v,int w){
        E[size]=edge(v,w,head[u]);
        head[u]=size++;
        E[size]=edge(u,0,head[v]);
        head[v]=size++;
    }
    int maxFlow(int src,int des){
        maxflow=0;
        for(int i=0;i<=n;i++){
            dis[i]=gap[i]=0;
            cur[i]=head[i];
        }
        int u=pre[src]=src;
        int aug=0;///or aug=-1
        while(dis[src]<n){
           loop:for(int &i=cur[u];i!=-1;i=E[i].next){
                int v=E[i].v;
                if(E[i].w&&dis[u]==dis[v]+1){
                    aug=min(aug,E[i].w);
                    pre[v]=u;
                    u=v;
                    if(v==des){
                        maxflow+=aug;
                        for(u=pre[u];v!=src;v=u,u=pre[u]){
                            E[cur[u]].w-=aug;
                            E[cur[u]^1].w+=aug;
                        }
                        aug=inf;
                    }
                    goto loop;
                }
            }
            int mdis=n;
            for(int i=head[u];i!=-1;i=E[i].next){
                int v=E[i].v;
                if(E[i].w&&mdis>dis[v]){
                    cur[u]=i;
                    mdis=dis[v];
                }
            }
            if(--gap[dis[u]]==0)break;
            gap[dis[u]=mdis+1]++;
            u=pre[u];
        }
        return maxflow;
    }
}G;

int f[maxn];//并查集
void init(int n){//并查集的初始化
    for(int i=0;i<=n;i++)f[i]=i;
}
int Find(int x){//带路径压缩的查找函数
    return x==f[x]?x:f[x]=Find(f[x]);
}
void Union(int x,int y){//直接合并
    x=Find(x);
    y=Find(y);
    if(x==y)return ;
    f[x]=y;
}
struct node{//保存原图，每次跑完最大流用于重新建立图，跑完最大流图是会被修改的 
    int x,y;
}p[maxn*maxn];
bool used[maxn][maxn];
void buildMap(int k,int n,int m){
    G.init(n*2+1);
    cl(used,false);
    for(int i=0;i<m;i++){
        int x=p[i].x;
        int y=p[i].y;
        //G.insert(x,y+n,1);
       // used[x][y]=1;
        for(int j=1;j<=n;j++){
            if(Find(j)==Find(x)&&!used[j][y]){//把和x在一起的女孩子，都连一条到y的边即可
                used[j][y]=true;
                G.insert(j,y+n,1);
            }
        }
    }
    for(int i=1;i<=n;i++){
        G.insert(0,i,k);
        G.insert(i+n,n*2+1,k);
    }
}
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        int n,m,t;
        scanf("%d%d%d",&n,&m,&t);
        for(int i=0;i<m;i++){
            scanf("%d%d",&p[i].x,&p[i].y);
        }
        init(n);
        for(int i=0;i<t;i++){
            int x,y;
            scanf("%d%d",&x,&y);
            Union(x,y);
        }
        int ans=-1;
        int l=0,r=n;
        while(l<=r){
            int mid=l+r>>1;
            buildMap(mid,n,m);
            if(G.maxFlow(0,2*n+1)>=n*mid){
                l=mid+1;
                ans=mid;
            }
            else {
                r=mid-1;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}