Marriage Match II(二分+并查集+最大流，好题)

Marriage Match II

http://acm.hdu.edu.cn/showproblem.php?pid=3081

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 5420    Accepted Submission(s): 1739

Problem Description

Presumably, you all have known the question of stable marriage match. A girl will choose a boy; it is similar as the game of playing house we used to play when we are kids. What a happy time as so many friends playing together. And it is normal that a fight or a quarrel breaks out, but we will still play together after that, because we are kids. 
Now, there are 2n kids, n boys numbered from 1 to n, and n girls numbered from 1 to n. you know, ladies first. So, every girl can choose a boy first, with whom she has not quarreled, to make up a family. Besides, the girl X can also choose boy Z to be her boyfriend when her friend, girl Y has not quarreled with him. Furthermore, the friendship is mutual, which means a and c are friends provided that a and b are friends and b and c are friend. 
Once every girl finds their boyfriends they will start a new round of this game—marriage match. At the end of each round, every girl will start to find a new boyfriend, who she has not chosen before. So the game goes on and on.
Now, here is the question for you, how many rounds can these 2n kids totally play this game?

 

Input

There are several test cases. First is a integer T, means the number of test cases. 
Each test case starts with three integer n, m and f in a line (3<=n<=100,0<m<n*n,0<=f<n). n means there are 2*n children, n girls(number from 1 to n) and n boys(number from 1 to n).
Then m lines follow. Each line contains two numbers a and b, means girl a and boy b had never quarreled with each other. 
Then f lines follow. Each line contains two numbers c and d, means girl c and girl d are good friends.

 

Output

For each case, output a number in one line. The maximal number of Marriage Match the children can play.

 

Sample Input

1
4 5 2
1 1
2 3
3 2
4 2
4 4
1 4
2 3

 

Sample Output

2

用并查集合并女生的关系，再用二分跑最大流，因为次数具有单调性，所以可以二分

#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<vector>
#include<set>
#define maxn 200005
#define MAXN 200005
#define mem(a,b) memset(a,b,sizeof(a))
const int N=200005;
const int M=200005;
const int INF=0x3f3f3f3f;
using namespace std;
int n;
struct Edge{
    int v,next;
    int cap,flow;
}edge[MAXN*20];//注意这里要开的够大。。不然WA在这里真的想骂人。。问题是还不报RE。。
int cur[MAXN],pre[MAXN],gap[MAXN],path[MAXN],dep[MAXN];
int cnt=0;//实际存储总边数
void isap_init()
{
    cnt=0;
    memset(pre,-1,sizeof(pre));
}
void isap_add(int u,int v,int w)//加边
{
    edge[cnt].v=v;
    edge[cnt].cap=w;
    edge[cnt].flow=0;
    edge[cnt].next=pre[u];
    pre[u]=cnt++;
}
void add(int u,int v,int w){
    isap_add(u,v,w);
    isap_add(v,u,0);
}
bool bfs(int s,int t)//其实这个bfs可以融合到下面的迭代里，但是好像是时间要长
{
    memset(dep,-1,sizeof(dep));
    memset(gap,0,sizeof(gap));
    gap[0]=1;
    dep[t]=0;
    queue<int>q;
    while(!q.empty())
    q.pop();
    q.push(t);//从汇点开始反向建层次图
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=pre[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].v;
            if(dep[v]==-1&&edge[i^1].cap>edge[i^1].flow)//注意是从汇点反向bfs，但应该判断正向弧的余量
            {
                dep[v]=dep[u]+1;
                gap[dep[v]]++;
                q.push(v);
                //if(v==sp)//感觉这两句优化加了一般没错，但是有的题可能会错，所以还是注释出来，到时候视情况而定
                //break;
            }
        }
    }
    return dep[s]!=-1;
}
int isap(int s,int t)
{
    if(!bfs(s,t))
    return 0;
    memcpy(cur,pre,sizeof(pre));
    //for(int i=1;i<=n;i++)
    //cout<<"cur "<<cur[i]<<endl;
    int u=s;
    path[u]=-1;
    int ans=0;
    while(dep[s]<n)//迭代寻找增广路,n为节点数
    {
        if(u==t)
        {
            int f=INF;
            for(int i=path[u];i!=-1;i=path[edge[i^1].v])//修改找到的增广路
                f=min(f,edge[i].cap-edge[i].flow);
            for(int i=path[u];i!=-1;i=path[edge[i^1].v])
            {
                edge[i].flow+=f;
                edge[i^1].flow-=f;
            }
            ans+=f;
            u=s;
            continue;
        }
        bool flag=false;
        int v;
        for(int i=cur[u];i!=-1;i=edge[i].next)
        {
            v=edge[i].v;
            if(dep[v]+1==dep[u]&&edge[i].cap-edge[i].flow)
            {
                cur[u]=path[v]=i;//当前弧优化
                flag=true;
                break;
            }
        }
        if(flag)
        {
            u=v;
            continue;
        }
        int x=n;
        if(!(--gap[dep[u]]))return ans;//gap优化
        for(int i=pre[u];i!=-1;i=edge[i].next)
        {
            if(edge[i].cap-edge[i].flow&&dep[edge[i].v]<x)
            {
                x=dep[edge[i].v];
                cur[u]=i;//常数优化
            }
        }
        dep[u]=x+1;
        gap[dep[u]]++;
        if(u!=s)//当前点没有增广路则后退一个点
        u=edge[path[u]^1].v;
     }
     return ans;
}

int m,d;
struct sair{
    int x,y;
}p[maxn];
int Friend[205][205];
int fa[maxn];

int Find(int x){
    int r=x,y;
    while(x!=fa[x]){
        x=fa[x];
    }
    while(r!=x){
        y=fa[r];
        fa[r]=x;
        r=y;
    }
    return x;
}

void join(int x,int y){
    int xx=Find(x);
    int yy=Find(y);
    if(xx!=yy){
        fa[xx]=yy;
    }
}
int tmp;
int Check(int mid){
    isap_init();
    int s=0,t=n+n+1;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            if(Friend[i][j]){
                add(i,j+n,1);
            }
        }
    }
    for(int i=1;i<=n;i++){
        add(s,i,mid);
        add(n+i,t,mid);
    }
    n=n+n+2;
    int tttt=isap(s,t);
    n=tmp;
    return tttt;
}

int main(){
    std::ios::sync_with_stdio(false);
    int T;
    cin>>T;
    for(int co=1;co<=T;co++){
        cin>>n>>m>>d;
        tmp=n;
        memset(Friend,0,sizeof(Friend));
        for(int i=0;i<=n;i++) fa[i]=i;
        for(int i=1;i<=m;i++) cin>>p[i].x>>p[i].y;
        for(int i=m+1;i<=m+d;i++) cin>>p[i].x>>p[i].y;
        for(int i=m+1;i<=m+d;i++) join(p[i].x,p[i].y);
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(Find(p[i].x)==Find(j)&&!Friend[j][p[i].y]){
                    Friend[j][p[i].y]=1;
                }
            }
        }
        int L=0,R=n,mid;
        while(L<=R){
            mid=(L+R)>>1;
            n=tmp;
            if(Check(mid)>=(n*mid)){
                L=mid+1;
            }
            else{
                R=mid-1;
            }
        }
        cout<<R<<endl;
    }
}