【HUST 1024 】 拆点+二分枚举可行流

题目链接：http://acm.hust.edu.cn/problem.php?id=1024

题目大意：有n个男孩和n个女孩参加party，现在让你将他们分成n对不同的舞伴（只能男和女），男孩女孩可以和自己喜欢的人，最多和k个自己不喜欢的异性配对，现在问你能跳多少次舞（n对配完一次跳一次舞，每次的舞伴都不能重复）。

解题思路：  网络流，关键在于建图。

               把男性拆成两个点，分别放置在两个集合内，Xa和Xb，女性拆成两个点，分别放置在Ya和Yb内。Xa到Xb连接一条有向边，权值为k，Yb到Ya连接一条有向边，权值为k。当boy喜欢girl时，Xa和Ya之间连接一条对应的有向边权值为1，当boy不喜欢girl时，Xb和Yb连接一条对应的有向边，权值为1。

             最后二分枚举可行解ans， 超级源点到Xa的每个点连接一条有向边，权值为ans，Ya内的每个点和超级汇点连接一条有向边，权值也为ans。最后流啊流，最大流满足max_flow==n*ans时，继续二分，直到找到最优解。

            这里要注意的是用一个tmp数组保存每条边的起始容量。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;

const int mn=1024;
const int mm=1000000;
const int oo=0x3fffffff;
int node, st, sd, edge;
int flow[mm], reach[mm], next[mm], tmp[mm];
int head[mn], work[mn], dis[mn], que[mn];
int map[110][110];

void init(int node_, int st_, int sd_)
{
    node=node_, st=st_, sd=sd_;
    for(int i=0; i<node; i++) head[i]=-1;
    edge=0;
}

void addedge(int u, int v, int c1, int c2)
{
    reach[edge]=v, flow[edge]=c1, tmp[edge]=c1, next[edge]=head[u], head[u]=edge++;
    reach[edge]=u, flow[edge]=c2, tmp[edge]=c2, next[edge]=head[v], head[v]=edge++;
}

bool bfs()
{
    int u, v, l=0, h=0;
    for(int i=0; i<node; i++) dis[i]=-1;
    que[l++]=st;
    dis[st]=0;
    while(l!=h)
    {
        u=que[h++];
        if(h==mn) h=0;
        for(int i=head[u]; i>=0; i=next[i])
        {
            v=reach[i];
            if(flow[i]&&dis[v]<0)
            {
                dis[v]=dis[u]+1;
                que[l++]=v;
                if(l==mn) l=0;
                if(v==sd) return true;
            }
        }
    }
    return false;
}

int dfs(int u, int exp)
{
    if(u==sd) return exp;
    for(int &i=work[u]; i>=0; i=next[i])
    {
        int v=reach[i], tp;
        if(flow[i]&&dis[v]==dis[u]+1&&(tp=dfs(v,min(flow[i],exp))>0))
        {
            flow[i]-=tp;
            flow[i^1]+=tp;
            return tp;
        }
    }
    return 0;
}

int Dinic()
{
    int max_flow=0, flow;
    while(bfs())
    {
        for(int i=0; i<node; i++) work[i]=head[i];
        while(flow=dfs(st,oo)) max_flow+=flow;
    }
    return max_flow;
}

void Update(int mid)
{
    for(int i=0; i<edge; i++) flow[i]=tmp[i];
    for(int i=head[st]; i>=0; i=next[i])
    {
        flow[i]=mid;
        flow[i^1]=0;
    }
    for(int i=head[sd]; i>=0; i=next[i])
    {
        flow[i]=0;
        flow[i^1]=mid;
    }
}

int main()
{
    int T, n, m, k;
    cin >> T;
    while(T--)
    {
        cin >> n >> m >> k;
        init(4*n+2,0,4*n+1);
        memset(map,0,sizeof(map));
        while(m--)
        {
            int u, v;
            scanf("%d%d",&u,&v);
            map[u][v]=1;
        }
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
            {
                  if(map[i][j])  addedge(i,3*n+j,1,0);
                  else addedge(n+i,2*n+j,1,0);
            }
        for(int i=1; i<=n; i++)
        {
            addedge(st,i,0,0);
            addedge(3*n+i,sd,0,0);
            addedge(i,n+i,k,0);
            addedge(2*n+i,3*n+i,k,0);
        }
        int l=0, r=n, mid, ans=0;
        while(l<=r)
        {
            mid=(l+r)>>1;
            Update(mid);
            if(Dinic()==n*mid)
            {
                ans=mid;
                l=mid+1;
            }
            else r=mid-1;
        }
        cout << ans <<endl;
    }
    return 0;
}