网络流之最大流

网络流的基本概念

在一张有向图中 G = (V, E) 中有一个源点 S 和一个汇点 T。

源点 S 有无限多的水流可以向外流出，汇点 T 可以接受无限多的水流。

其中对于每一条有向边有一个边权代表这条有向边最大可以流过的流量(用 c(u, v) 来表示)。

最大流指的是最大可行流

残留网络

然后每一个流都会有一个残留网络
残留网络指的是在原网络中指定了可行流之后对应的一个网络流，原网络的一个可行流对应一个残留网络。

该红色箭头的所指路径即为残留网络
其中的
其中残留网络的可行流 f’ 同样需满足
流量守恒，容量限制的条件

我们最主要的还是想知道网络流如何来做题目的，我们必须要用到最经典的网络流模板dinic算法，dinic可以求解很多的网络流的问题，但是有些省赛的题目很恶心，有些出题人会故意卡dinic的递归，上次wa了1下午巨恶心；

dinic的算法模板

void add(int a,int b,int c)
{
    e[idx]=b,ne[idx]=h[a],f[idx]=c,h[a]=idx++;
    e[idx]=a,ne[idx]=h[b],f[idx]=0,h[b]=idx++;
}

bool bfs()
{
    memset(d,-1,sizeof d);
    int hh=0,tt=0;
    q[0]=S;
    d[S]=0,cur[S]=h[S];
    while(hh<=tt)
    {
        int t=q[hh++];
        for(int i=h[t];~i;i=ne[i])
        {
            int j=e[i];
            if(d[j]==-1&&f[i])
            {
                d[j]=d[t]+1;
                cur[j]=h[j];
                if(j==T) return true;
                q[++tt]=j;
            }
        }
    }return false;
}

int find(int u,int limit)
{
    if(u==T) return limit;
    int flow=0;
    for(int i=cur[u];~i&&flow<limit;i=ne[i])
    {
        int j=e[i];
        cur[u]=i;
        if(d[j]==d[u]+1&&f[i])
        {
            int t=find(j,min(f[i],limit-flow));
            if(!t) d[j]=-1;
            f[i]-=t,f[i^1]+=t,flow+=t;
        }
    }return flow;
    
}

int dinic()
{
    int r=0,flow;
    while(bfs()) while(flow=find(S,inf)) r+=flow;
    return r;
}

第一道题，网络流求解二分图最大匹配

二分图匹配是一个多源点的问题，所以我们可以设定一个超级源点S
从S流向左边的点并且这条边的容量f即为1，如果是像圆桌问题那种多重匹配的问题的话，我们就可以设容量f为该公司的人
同样建立一个超级汇点来接入这些右边的点
一个多重的二分匹配问题

建图就是S流向每个公司容量就是公司人数，求一边dinic

#include<bits/stdc++.h>
using namespace std;
const int N=10010,M=200010,inf=1e9;
int e[M],ne[M],f[M],h[N],idx;
int cur[N],d[N],q[N];
int n,m,S,T;

void add(int a, int b, int c)
{
    e[idx] = b, f[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
    e[idx] = a, f[idx] = 0, ne[idx] = h[b], h[b] = idx ++ ;
}
bool bfs()
{
    memset(d,-1,sizeof d);
    int hh=0,tt=0;
    q[0]=S;
    cur[S]=h[S],d[S]=0;
    while(hh<=tt)
    {
        int t=q[hh++];
        for(int i=h[t];~i;i=ne[i])
        {
            int j=e[i];
            if(d[j]==-1&&f[i])
            {
                d[j]=d[t]+1;
                cur[j]=h[j];
                if(j==T) return true;
                q[++tt]=j;
            }
        }
    }
    return false;
}

int find(int u,int limit)
{
    if(u==T) return limit;
    int flow=0;
    for(int i=cur[u];~i&&flow<limit;i=ne[i])
    {
        cur[u]=i;
        int j=e[i];
        if(d[j]==d[u]+1&&f[i])
        {
            int t=find(j,min(f[i],limit-flow));
            if(!t) d[j]=-1;
            f[i]-=t,f[i^1]+=t,flow+=t;
        }
    }
    return flow;
}

int dinic()
{
    int r=0,flow;
    while(bfs()) while(flow=find(S,inf)) r+=flow;
    return r;
}
int main()
{
    memset(h,-1,sizeof h);
    scanf("%d%d",&n,&m);
    S=0,T=n+m+1;
    int tot=0;
    for(int i=1;i<=n;i++)
    {
        int c;
        scanf("%d",&c);
        add(S,i,c);
        tot+=c;
    }
    for(int i=1;i<=m;i++)
    {
        int c;
        scanf("%d",&c);
        add(i+n,T,c);
    }
    
    for(int i=1;i<=n;i++)
     for(int j=1;j<=m;j++)
      add(i,j+n,1);
    
    if(dinic()!=tot) puts("0");//如果总人数不等于匹配人数
    else
    {
        puts("1");
        for(int i=1;i<=n;i++)
       {  for(int j=h[i];~j;j=ne[j])
             if(e[j]>n&&e[j]<=m+n&&!f[j])
             printf("%d ",e[j]-n);
             puts(" ");
         }
    }
    
    return 0;
}