图论学习-网络流之最大流初步

图论学习-网络流初步

一、基本概念

1.1 术语

1.2 原理

1.3 最大流最小割定理

基本内容：
对于流网络G，有一个可行流f：
那么对于该可行流的残留网络Gf,如果不存在增广路，则f是一个最大流

二、算法模板

2.1 EK O(n * m^2)

每一次维护一个残留网络，去找残留网络的增广路，如果找不到增广路，那么目前的f就是最大流。
每一次只会增广一条路。

2.1.1 代码实现

#include<bits/stdc++.h>
using namespace std;

const int N = 1e3+10,M = 2e4+10;
int h[N],e[M],ne[M],idx;
int f[M],d[M],q[M],pre[M];
int n,m,S,T;
int res;
bool st[N];
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(st, 0, sizeof st);
    int hh = 0,tt = -1;
    q[++tt] = S;
    st[S] = true;
    d[S] = 1e9;
    while(hh<=tt)
    {
        int t = q[hh++];
        for(int i = h[t];~i;i = ne[i])
        {
            int j = e[i];
            if(!st[j]&&f[i])
            {
                st[j] = true;
                d[j] = min(d[t],f[i]);
                pre[j] = i;
                if(j==T) return true;
                q[++tt] = j;
            }
        }
    }
    return false;
}
void EK()
{
    int r = 0;
    while(bfs())
    {
        r+=d[T];
        for(int i = T;i!=S;i = e[pre[i]^1])
        {
            f[pre[i]]-=d[T];
            f[pre[i]^1]+=d[T];
        }
    }
    cout<<r;
}
int main()
{
    memset(h, -1, sizeof h);
    cin>>n>>m>>S>>T;
    for(int i = 0;i<m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }
    EK();
    return 0; 
}

2.2 dinic O(m * n^2)

2.2.1 原理

对EK算法的优化，对当前可以增广的路爆搜一遍，把所有的当前能增广的道路均增广。

2.2.2 小注

由于图中可能存在环，直接对原图爆搜的话可能会死循环，所以采用分层图的方式，先预先bfs把图中点的层次确定出来，建立分层图，随后在分层图中爆搜所有可以增广的道路，这样就不会死循环了。

2.2.3 实现步骤

0.存图，（维护残留网络）
1.bfs建立分层图
2.dfs找出所有能增广的路径
3.做增广

2.2.4 需要注意的地方

1. 当前弧优化：在搜索过程中，发现流量已经流满了，那么其实可以跳过，不用dfs了，比如fi<limit,那么在以后再搜到fi这条边时，这条边就可以直接跳过了，因为已经前面已经把这条边流满了。
   
2. 废点优化：如果当前点无法流到终点，就删去。
3. 流量优化：如果当前流量大于最多能流的流量，就跳过。

2.2.3 代码实现

y总原话：推荐背过:)

#include<bits/stdc++.h>
using namespace std;

const int N = 1e4+10,M = 2e5+10;
int h[N], e[M], f[M], ne[M], idx;//f表示当前残留网络的容量
int q[N], d[N], cur[N];//cur记录的是当前弧
int n,m,S,T;
int INF = 1e9;

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()
{
    int hh = 0,tt = 0;
    memset(d,-1,sizeof d);
    //当前弧优化，在搜索过程中，发现流量已经流满了，那么其实可以跳过，不用dfs了
    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)
{
    //limit表示从源点能够流向u这个点的最大流量
    if(u==T) return limit;
    int flow = 0;//flow表示从当前点u,往后能够流的最大流量
    for(int i = cur[u];~i&&flow<limit;i = ne[i])
    {
        cur[u] = i;
        int ver = e[i];
        if(d[ver]==d[u]+1&&f[i])
        {
            int t = find(ver,min(f[i],limit-flow));
            if(!t)
            {
                d[ver] = -1;//删掉该点
            }
            f[i]-=t,f[i^1]+=t,flow+=t;
        }
    }
    return flow;
}
int dinic()
{
    int r = 0,flow;
    while(bfs())
    {
        //bfs返回是否有增广路
        while(flow = find(S,INF)) r+=flow;
    }        
    return r;
}
int main()
{
    cin>>n>>m>>S>>T;
    memset(h, -1, sizeof h);
    while (m -- ){
        int a,b,c;
        cin>>a>>b>>c;
        add(a, b, c);
    }
    cout<<dinic();
    return 0;
}

三、应用

四、拓展