HDU 3081 Marriage Match II <<二分最大流 + 并查集

题意

n个女孩子跟n个男孩子过家家，女孩子选男孩子，告诉你每个女孩子可选的男孩子与女孩子之间的好友关系，好友关系是互相的而且是传递的，然后如果两个女孩子是好友，他们可选的男孩子也是可以合并的。然后每一轮进行匹配，匹配成功后开始下一轮，每个女孩子只能选同一个男孩子一次，问最多能玩几轮。

思路

首先，好友关系的建立显然就直接想到了用并查集处理。

然后在建图时，可以选择是二分图，然后跑完备匹配，每次匹配完后删除匹配边进行下一次匹配。

当然，不会二分图的我就选择直接跑网络流啦，但是建图时候发现需要知道流量，这时候，就是二分答案的地方了。

具体建图：

从S向i建容量为K的边，从i向每个与他能匹配的i+n建容量为1的边，最后从i+n到T建容量为K的边

通过判断是否满流，来判断当前K是否可行，即判断maxflow==K*n

代码

#include<bits/stdc++.h>
using namespace std;
const int maxn=205;
const int INF=0x3f3f3f3f;
struct Edge{
    int from,to,cap,flow;
};
struct DINIC{
    int n,m,s,t;
    vector<Edge> edges;
    vector<int> G[maxn];
    bool vis[maxn];
    int d[maxn];
    int cur[maxn];

    void init()
    {
        edges.clear();
        for(int i=0;i<maxn;i++)
            G[i].clear();
    }
    void AddEdge(int from,int to,int cap,int c=0)
    {
        edges.push_back(Edge {from,to,cap,0});
        edges.push_back(Edge {to,from,c,0});
        m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    bool BFS()
    {
        memset(vis,0,sizeof(vis));
        queue<int> Q;
        Q.push(s);
        d[s]=0;
        vis[s]=1;
        while(!Q.empty())
        {
            int x=Q.front();Q.pop();
            for(int i=0;i<G[x].size();i++)
            {
                Edge& e=edges[G[x][i]];
                if(!vis[e.to]&&e.cap>e.flow)
                {
                    vis[e.to]=1;
                    d[e.to]=d[x]+1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int DFS(int x,int a)
    {
        if(x==t||a==0) return a;
        int flow=0,f;
        for(int& i=cur[x];i<G[x].size();i++)
        {
            Edge& e=edges[G[x][i]];
            if(d[x]+1==d[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow)))>0)
            {
                e.flow+=f;
                edges[G[x][i]^1].flow-=f;
                flow+=f;
                a-=f;
                if(a==0) break;
            }
        }
        return flow;
    }
    int Maxflow(int s,int t)
    {
        this->s=s;this->t=t;
        int flow=0;
        while(BFS())
        {
            memset(cur,0,sizeof(cur));
            flow+=DFS(s,INF);
        }
        return flow;
    }
}ANS;
int N,F,M,SS,TT;
int far[105];
bool dist[maxn][maxn];
void init()
{
    memset(dist,0,sizeof(dist));
    for(int i=0;i<=N;i++)
    {
        far[i]=i;
    }
}
int Find(int x)
{
    if(far[x]==x) return x;
    else return far[x]=Find(far[x]);
}
void Union(int x,int y)
{
    x=Find(x),y=Find(y);
    if(x!=y) far[y]=x;
}
void build(int now)
{
    ANS.init();
    for(int i=1;i<=N;i++)
    {
        ANS.AddEdge(SS,i,now);
        for(int j=N+1;j<=N*2;j++)
            if(dist[i][j]) ANS.AddEdge(i,j,1);
    }
    for(int i=N+1;i<=2*N;i++)
        ANS.AddEdge(i,TT,now);
}
bool check(int now)
{
    build(now);
    return ANS.Maxflow(SS,TT)==N*now;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&N,&M,&F);
        SS=0,TT=2*N+1;
        init();
        int low=0,high=N+1;
        for(int i=0,u,v;i<M;i++)
        {
            scanf("%d%d",&u,&v);
            dist[u][v+N]=1;
        }
        for(int i=1,u,v;i<=F;i++)//并查集操作
        {
            scanf("%d%d",&u,&v);
            Union(u,v);
        }
        for(int i=1;i<=N;i++)//合并共用边，这里是抄网上大佬的
        {
            for(int j=i+1;j<=N;j++)
            {
                if(Find(i)==Find(j))
                {
                    for(int k=N+1;k<=N*2;k++)
                        dist[i][k]=dist[j][k]=(dist[i][k]||dist[j][k]);
                }
            }
        }
        while(high-low>1)//二分
        {
            int mid=(low+high)>>1;
            if(check(mid)) low=mid;
            else high=mid;
        }
        printf("%d
",low);
    }
}