网络流——基础，Dinic和Sap（Gap优化）算法

网络流的三个基本性质：

1、容量限制:  f[u,v]<=c[u,v]

2、反对称性：f[u,v] = - f[v,u]

3、流量平衡:  对于不是源点也不是汇点的任意结点,流入该结点的流量和等于流出该结点的流量和。

增广路算法：

每次暴力找一条由源点到汇点的增广路，算入答案，记得连反向弧。

时间复杂度：O（ n6 ）

听说有一种算法叫两百行的高标推进，非常快——

Dinic：

每次给算出源点到各个点的最短距离，然后我们按照最短路径找增广路，直到源点不能找到汇点；

cur当前弧优化：

如果这条弧已经流完，那么我们下次没有必要再经过它，于是在链式前向星里标记就好了。

二分图时间复杂度：O（ nm−−√ ）

Code:

#include 
#include 
#include 

using namespace std;

const int maxn = 100005,maxm = 100005;

struct node
{
    int to,next,flow;//目标点，下一条边，剩余流量

    node(void){}
    node(int a,int b,int c) : to(a),next(b),flow(c){}
}e[maxm * 2];//正向+反向弧

int d[maxn];//距离标号，距离原点的最短距离
int final[maxn],cur[maxn];
int n,m,tot,s,t;

void link(int u,int v,int c)
{
    e[++ tot] = node(v,final[u],c),final[u] = tot;
    e[++ tot] = node(u,final[v],0),final[v] = tot;
// 2 3 
    //这里保证了正，反向弧的标号连续，那么对于第i条边，其反向弧就是i^1
}

bool bfs()
{
    //用bfs找到每个点的距离标号
    static int que[maxn];
    for(int i = s;i <= t;i ++) d[i] = -1,cur[i] = final[i];
    d[s] = 0;
    que[1] = s;
    for(int fi = 1,en = 1;fi <= en;fi ++)
    {
        int u = que[fi];
        for(int i = final[u];i;i = e[i].next)
            if (e[i].flow > 0 && d[e[i].to] == -1)
            {
                d[e[i].to] = d[u] + 1;
                que[++ en] = e[i].to;
            }
    }
    return d[t] != -1;
}

int dfs(int now,int flow)
{
    if (now == t) return flow;//流完，退出
    int use = 0;
    for(int i = cur[now];i;i = e[i].next)
    {
                cur[now] = i;
        if (e[i].flow > 0 && d[e[i].to] == d[now] + 1/*只能沿着最短路走*/)
        {
            int tmp = dfs(e[i].to,min(e[i].flow,flow - use));
            use += tmp,e[i].flow -= tmp,e[i ^ 1].flow += tmp;
            if (flow == use) return use;
        }
    }
    return use;
}

int main()
{
    tot = 1;//计算反向弧时更方便
    scanf("%d%d", &n, &m);//n为点数，m为边数
    s = 1,t = n;//假定原点为s，汇点为t
    for(int i = 1;i <= m;i ++)
    {
        int u,v,c;
        scanf("%d%d%d", &u, &v, &c);//一条从u到v，流量为c的边
        link(u,v,c);
    }
    int ans = 0;
    for(;bfs()/*假如找不到证明无法增广*/;)
        ans += dfs(s,1 << 30);
    printf("%d\n", ans);
    return 0;
}

Sap:

Dinic每次需要宽搜，最多n次，影响了时间。

sap的思想是分层图的思想，这一层我们流完了，那么我们就绕远路去另外一层。

记录 dx 表示x的层数，我们本来只去x+1这一层，现在x+1层流完了，就去x+2层。

gap优化：
用co统计每一层的个数，如果出现了断层，就说明源点不能再流到汇点了，直接退出。

为了代码实现方便，通常使 co0 =0，而不是宽搜弄初始层数。

Code：

#include 
#include 
#include 

using namespace std;

const int maxn = 100005,maxm = 100005;

struct node
{
    int to,next,flow;//目标点，下一条边，剩余流量

    node(void){}
    node(int a,int b,int c) : to(a),next(b),flow(c){}
}e[maxm * 2];//正向+反向弧

int d[maxn];//距离标号，距离汇点的最短距离
int co[maxn];//co[i] = |{k|d[k]=i}|，gap优化
int final[maxn],cur[maxn];
int n,m,tot,s,t;

void link(int u,int v,int c)
{
    e[++ tot] = node(v,final[u],c),final[u] = tot;
    e[++ tot] = node(u,final[v],0),final[v] = tot;
    //这里保证了正，反向弧的标号连续，那么对于第i条边，其反向弧就是i^1
}

int dfs(int now,int flow)
{
    if (now == t) return flow;//流完，退出
    int use = 0;
    for(int i = cur[now];i;i = e[i].next)
    {
        cur[now] = i;//当前弧优化
        if (e[i].flow > 0 && d[e[i].to] + 1 == d[now]/*只能沿着最短路走*/)
        {
            int tmp = dfs(e[i].to,min(e[i].flow,flow - use));
            use += tmp,e[i].flow -= tmp,e[i ^ 1].flow += tmp;
            if (flow == use) return use;
        }
    }
    cur[now] = final[now];
    if (!(-- co[d[now]])) d[s] = n;//gap
    ++ co[++ d[now]];
    return use;
}

int main()
{
    tot = 1;//计算反向弧时更方便
    scanf("%d%d", &n, &m);//n为点数，m为边数
    s = 1,t = n;//假定原点为s，汇点为t
    for(int i = 1;i <= m;i ++)
    {
        int u,v,c;
        scanf("%d%d%d", &u, &v, &c);//一条从u到v，流量为c的边
        link(u,v,c);
    }
    co[0] = n;//初始化，每个点的d都为0
    int ans = 0;
    for(;d[s] < n;) ans += dfs(s,1 << 30/*一个较大的值*/);
    printf("%d\n", ans);
    return 0;
}

总结

在赛场时，因为网络流复杂度玄学，通常把两种算法都打了，比较一下在这种图下是Dinic快还是Sap快，再提交。

网络流真正的难点永远是建图，所以算法实现倒不显得那么重要，可是也必须熟练掌握，清楚每个步骤的原理。