Dinic/ISAP求最大流

给定一个包含 $n$ 个点 $m$ 条边的有向图，并给定每条边的容量，边的容量非负。

图中可能存在重边和自环。求从点 $S$ 到点 $T$ 的最大流。

输入格式

第一行包含四个整数 $n,m,S,T$。
接下来 $m$ 行，每行三个整数 $u,v,c$，表示从点 $u$ 到点 $v$ 存在一条有向边，容量为 $c$。

点的编号从 $1$ 到 $n$。

输出格式

输出点 $S$ 到点 $T$ 的最大流。

如果从点 $S$ 无法到达点 $T$ 则输出 $0$。

数据范围

$2\le n\le 1000$,
$1\le m\le 10000$,
$0\le c\le 10000$,
$S\ne T$

输入样例：

7 14 1 7
1 2 5
1 3 6
1 4 5
2 3 2
2 5 3
3 2 2
3 4 3
3 5 3
3 6 7
4 6 5
5 6 1
6 5 1
5 7 8
6 7 7

输出样例：

14

本人的遇到的问题

• dinic 算法是对 EK 算法的一种优化，因为 EK 算法一次只能走一条路，太慢了，所以 dinik 一次能走好多条路，快很多。因此时间复杂度为 $O(n^{2}m)$。
• 那 dinic 怎么实现走多条路呢？这里找所有的增广路径，如果存在环的话，会有无数条增广路径，可以借助分层图的思想解决该问题：使用 bfs 建立分层图，从源点开始，每次扩展一层，每层给一个编号。之后按照每层使用 dfs 找出所有能增广的路径（代码中 dfs 函数名称为 find）。
• 注意：上述的 bfs 有两个作用：建立分层图、判断是否存在增广路。
• 每次我们在使用 bfs 建立分层图之后，我们会调用多次 find 函数找到对应于当前分层图的所有增广路，在这个分层图中，我们可以使用当前弧优化。
• 当前弧优化：对于每个点，我们记录它应该从哪条边开始遍历，而不是全部从头遍历。
• 因此，我们代码中的 cur 为当前弧优化, 存储从当前节点开始还需要遍历的点的编号；d 为点在分层图中的编号(本质就是到源点最短路径, S到S定义为0)。

代码中的细节

• flow < limit 说明还有必要搜从u出去的剩余的边。
• cur[u] = i，为弧优化：如果进入循环，说明搜到从u出去编号为i的弧(边)，进而说明前面从 u 指出去的弧已经被搜完了, 这些弧的流量已经被没了，因此 dinic 下一次调用 find 时，直接从 i 开始搜即可。
• t==0 说明不能找到从ver到T的增广路。因此下一次遍历到ver时直接跳过即可, 将d[ver]标记为-1即可。
• r: 最大流大小 flow: 每次增广后可以增加的流量。
• find 函数的参数为：从起点S到当前点u允许流过的最大流量为limit。

代码

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>

using namespace std;

const int N = 1e5+10,M = 2*N,INT = 2e9;

int e[M],ne[M],h[N],f[M],idx;
int d[N],cur[N];//cur为当前弧优化，存储从当前节点开始还需要遍历的点的编号
//d为点在分层图中的编号(本质就是到源点最短路径, S到S定义为0)
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(){
    
    queue<int>q;
    
    memset(d,-1,sizeof d);
    
    d[S]=0,cur[S]=h[S];
    
    q.push(S);
    
    while(q.size()){
        int t=q.front();
        q.pop();
        
        for(int i=h[t];~i;i=ne[i]){
            int ver=e[i];
            
            if(d[ver]==-1&&f[i]){
                d[ver]=d[t]+1;
                cur[ver]=h[ver];
                if(ver==T)return true;
                q.push(ver);
            }
        }
    }
    
    return false;
}
// 从起点S到当前点u允许流过的最大流量为limit
int find(int u,int lim){
    if(u==T)return lim;
    
    int flow=0;
    // i = cur[u] 跳过前面从u出去的已经流满的路径
    // flow < limit 说明还有必要搜从u出去的剩余的边
    for(int i=h[u];~i&&flow<lim;i=ne[i]){
        // 如果进入循环，说明搜到从u出去编号为i的弧(边)
        // 进而说明前面从u指出去的弧已经被搜完了, 这些弧的流量已经被没了
        // 因此dinic下一次调用find时，直接从i开始搜即可
        cur[u]=i;//当前弧优化，减少已经算过的地方重复计算
        
        int ver=e[i];
        
        if(d[ver]==d[u]+1&&f[i]){//d其实就是一个层数
            int t=find(ver,min(f[i],lim-flow));
            // t==0 说明不能找到从ver到T的增广路
            // 因此下一次遍历到ver时直接跳过即可, 将d[ver]标记为-1即可
            if(!t)d[ver]=-1;
            f[i]-=t,f[i^1]+=t,flow+=t;
        }
    }
    
    return flow;
}

int dinic(){
    int r=0,flow;
    // r: 最大流大小  flow: 每次增广后可以增加的流量
    // bfs建立分层图过程中发现有增广路, 则找出所有的增广路, 将所有能够增加的流量加到答案中
    // 这里不能只进行一遍bfs遍历然后对find进行循环, 因为find会使得残留网络改变，下次得到的分层图会不同
    
    while(bfs())while(flow=find(S,INT))r+=flow;
    
    return r;
}

int main(){
    cin>>n>>m>>S>>T;
    
    memset(h,-1,sizeof h);
    
    for(int i=1;i<=m;i++){
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }
    
    cout<<dinic();
    
    return 0;
    
}