Plug It In!(网络流板子)

问题 E: Plug It In!

时间限制: 12 Sec  内存限制: 128 MB

题目描述

Adam just moved into his new apartment and simply placed everything into it at random. This means in particular that he did not put any effort into placing his electronics in a way that each one can have its own electric socket.
Since the cables of his devices have limited reach, not every device can be plugged into every socket without moving it first. As he wants to use as many electronic devices as possible right away without moving stuff around, he now tries to figure out which device to plug into which socket. Luckily the previous owner left behind a plugbar which turns one electric socket into 3. 
Can you help Adam figure out how many devices he can power in total?

输入

The input consists of:
• one line containing three integers m, n and k, where
– m (1 ≤ m ≤ 1 500) is the number of sockets;
– n (1 ≤ n ≤ 1 500) is the number of electronic devices;
– k (0 ≤ k ≤ 75 000) is the number of possible connections from devices to sockets.
• k lines each containing two integers xi and yi indicating that socket xi can be used to power device yi .
Sockets as well as electronic devices are numbered starting from 1.
The plugbar has no cable, i.e. if it is plugged into a socket it simply triples it.

输出

Output one line containing the total number of electrical devices Adam can power.

样例输入

复制样例数据

3 6 8
1 1
1 2
1 3
2 3
2 4
3 4
3 5
3 6

样例输出

5

 

---

题意 n个插头，m条电线，有一个 一转三的插座，输出最大可连的设备数；

二分图匹配题；最大匹配数=网络流的最大流；但是一转三的插头，应该通过枚举加一条S到插头点的边，由于图跑一边网络流，就不能再用了，所以要先存起来；

#include<bits/stdc++.h>
#define INF LLONG_MAX/2
#define N 80500
using namespace std;
 
struct ss
{
    int v,next;
    long long flow;
};
int head[N],now_edge=0,S,T;
ss edg[N*10];
 
ss lsedg[N*10];
int lshead[N],lssum_edge;
void init() //初始化
{
    now_edge=0;
    memset(head,-1,sizeof(head)); 
}
 
void addedge(int u,int v,long long flow) //加边,加双向边,反向边为0
{
    edg[now_edge]=(ss)
    {
        v,head[u],flow
    };
    head[u]=now_edge++;
    edg[now_edge]=(ss)
    {
        u,head[v],0
    };
    head[v]=now_edge++;
}
 
int dis[N];
 
int bfs() //这个过程给网络分层，避免循环跑；
{
    memset(dis,0,sizeof(dis));
    queue<int>q;
    q.push(S);
    dis[S]=1;
 
    while(!q.empty())
    {
        int now=q.front();
        q.pop();
 
        for(int i=head[now]; i!=-1; i=edg[i].next)
        {
            ss &e=edg[i];
            if(e.flow>0&&dis[e.v]==0)
            {
                dis[e.v]=dis[now]+1;
                q.push(e.v);
            }
        }
    }
 
    if(dis[T]==0)return 0;
    return 1;
}
 
int current[N];//就是记录了当前搜索到了这个点的哪一条边
long long dfs(int x,long long maxflow)
{
    if(x==T)return maxflow;
    for(int i=current[x]; i!=-1; i=edg[i].next)
    {
        current[x]=i;//然后接下来直接从这个边搜索就行了
 
        ss &e=edg[i];
        if(e.flow>0&&dis[e.v]==dis[x]+1)  //流量大于0，且在下一层
        {
            long long flow=dfs(e.v,min(maxflow,e.flow)); //在最大流和当前流取较小值
 
            if(flow!=0)
            {
                e.flow-=flow;
                edg[i^1].flow+=flow;
                return flow;
            }
        }
    }
    return 0;
}
 
long long dinic()
{
    long long ans=0,flow;
 
    while(bfs())
    {
        for(int i=0; i<N; i++)current[i]=head[i];
        while(flow=dfs(S,INF))ans+=flow;
    }
    return ans;
}
 //以上都是板子,用于求最大流
//二分图匹配问题，二分图的每条边权值都是1，二分图最大匹配就是最大流
int main()
{
    int m,n,k;
    long long  res=0;
    scanf("%d%d%d",&m,&n,&k);
    init();
    S=n+m+1,T=S+1;
    for(int i=0; i<k; i++)
    {
        int u,v;
        scanf("%d %d",&u,&v);
        addedge(u,v+m,1); //把u，v都变成不重复的数值
    }
    for(int i=1; i<=m; i++)
    {
        addedge(S,i,1); //把起点与二分图的一半连起来
    }
    for(int i=1; i<=n; i++)
    {
        addedge(i+m,T,1); //与终点连起来
    }
    long long nowmax=dinic(); //跑一边最大流
    long long cancan=0;
 
    for(int i=0; i<now_edge; i++)  //将图存起来
    {
        lsedg[i].flow=edg[i].flow;
        lsedg[i].next=edg[i].next;
        lsedg[i].v=edg[i].v;
    }
    for(int i=0;i<=n+m+2;i++)lshead[i]=head[i]; 
    lssum_edge=now_edge;
 
    for(int i=1; i<=m; i++) //然后手动把图复制，枚举起点到二分图的点，且权值为2
    {
        now_edge=lssum_edge;
        for(int i=0; i<now_edge; i++)
        {
            edg[i].flow=lsedg[i].flow;
            edg[i].next=lsedg[i].next;
            edg[i].v=lsedg[i].v;
        }
        for(int i=0;i<=n+m+2;i++)head[i]=lshead[i];
 
        addedge(S,i,2);
        long long dangqiancancan=dinic();
 
        cancan=max(cancan,dangqiancancan);//维护一个最大值
    }
    printf("%lld
",cancan+nowmax);
 
    return 0;
}