给定一个包含 n n n 个点 m m m 条边的有向图,并给定每条边的容量,边的容量非负。
图中可能存在重边和自环。求从点 S S S 到点 T T T 的最大流。
输入格式
第一行包含四个整数
n
,
m
,
S
,
T
n,m,S,T
n,m,S,T。
接下来
m
m
m 行,每行三个整数
u
,
v
,
c
u,v,c
u,v,c,表示从点
u
u
u 到点
v
v
v 存在一条有向边,容量为
c
c
c。
点的编号从 1 1 1 到 n n n。
输出格式
输出点 S S S 到点 T T T 的最大流。
如果从点 S S S 无法到达点 T T T 则输出 0 0 0。
数据范围
2
≤
n
≤
1000
2 \le n \le 1000
2≤n≤1000,
1
≤
m
≤
10000
1 \le m \le 10000
1≤m≤10000,
0
≤
c
≤
10000
0 \le c \le 10000
0≤c≤10000,
S
≠
T
S \neq T
S=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 ) O(n^2m) O(n2m)。
- 那 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;
}