网络流 ———— 从零开始（的异世界）
更好的阅读体验
最大流
首先，我们要知道什么是网络流，我们可以类比水流在水管里面的流动，假设在一个类似于有向图中的水管道中，有一个自来水厂(S)点，里面有源源不断的自来水流出，然后在另一个(T)点有一个基饥♂渴的人正在等待着喝水，他已经(0x7fffffff)年没有喝过水啦，所以我们要想办法能让他喝到尽可能多的水。我们知道，每一根管子都有各自的粗♂细，也就是容量，从S点流出的流量不能超过这条路径上的任意一条边的容量，不然管子就会爆掉的。
而求这个人能够喝到的水的最大量就是最大流问题。这个(S)点称为源点，这个(T)点称为汇点，这样的图就叫做网络流。
比如下面这个图的最大流就是(1)+(2)+(2)=(5)。
要注意：一个图的最大流路径并不是只有一个（有例外啦），比如上图在上方就是(1)，中间就是(2)，下方也是(2)，然后才总汇成了最大流(5)。
然后是可行流，就是假如所有边上的流量都没有超过容量，那么这一组流称为一组可行流，而很显然，一个网络流的最大流就是所有可行流中流量最大的一种。然后可行流中最简单的就是零流。也就是流量为(0)啦。
然后对于求最大流的算法，这里；列举出了两种：
1：(EK)算法 ((Edmonds-Karp))
首先，我们从最简单的零流开始，假设我们搜索到了一条路径(A)，从源点可以到达汇点，即A:{(S)->(a1)->(a2)->...->(T)},然后要注意，这条路上的每一条边满足的条件是流量<容量。并不是<=，因为这样会造成程序死循环。
然后我们可以找到这条路上的每一条边的剩余量的最小值(rest)，就是说我这个流的每一条边都有这(rest)的容量剩余，那么显而易见，我们将这条路上的所有边的流量都加上(rest)仍然是一个可行流。
就这样，我们找到了一个比一开始的流更大的流，也就是之前的流量+(rest)，我们称这条路为增广路。我们从(S)开始不断地寻找增广路，每次增广候我们都会得到一个比原来更大的流。这也就是为什么之前的流量是严格小于容量的，如果是=的话，程序就会一直寻找到(rest)的最小值为(0)，就会形成死循环。
而当找不到增广路的时候，当前的流就是最大流了。
然后具体的算法实现还是有些东西的。举一个已经用烂了的例子来说明吧。
在这里，我们假设傻傻的程序先找到了(1)->(2)->(3)->(4)这条路径，我们就会发现程序找出来的最大流为(1)，然后更改{(1)->(2)}、{(2)->(3)}、{(3)->(4)}的(rest)为(0)。
然而我们能很明显的看出来如果流{(1)->(2)->(4)}、{(1)->(3)->(4)}的话，能够得到更大的流量2，于是我们就知道这个程序是有问题的咯。所以我们反思：为什么会出错呢？
答案就是：你可能很聪明，一眼就看出来怎么走，但是程序是傻的，它只会按照你给的机制跑，但是很无奈你并没有给它一个反悔的机制，于是就凉凉了~
在这里我们采用加反向边的做法，对每一条{(a[i]->a[j])}都建一条容量为(0)的反向边{(a[j]->a[i])}。然后整个图建完是这样的：
我们在每一次找到增广路的时候会将每一段的容量减少(rest)，同时我们也将这些反向边容量增加(rest)。即：
(cap[a[i]][a[j]])-=(rest); (cap[a[j]][a[i]])+=(rest);
然后按刚才的方法我们先找到了(1)->(2)->(3)->(4),然后更改.
然后我们再次寻找增广路，找到(1)->(3)->(2)->(4),(rest)为(1)，再次增广之后，我们得到了最大流2。就相当与是把流进来的(2)->(4)又给退了回去，最后结果就是选了(1)->(2)->(4)、(1)->(3)->(4)。这就是原由。
而这个网络流版本就是(EK)算法。
#define MAXN 100010
#define INF 0x7fffffff
bool visit[MAXN];
int pre[MAXN];
queue<int> q;
void update(int now,int rest){
while(pre[now]){
map[pre[now]][now]-=rest;//正向的-=rest
map[now][pre[now]]+=rest;//负向的+=rest
now=pre[now];
}
}
int find(int S,int T){//寻找增广路流量
memset(visit,0,sizeof(visit));
memset(pre,-1,sizeof(pre));
visit[S]=1; int minn=INF;
q.push(S);
while(!q.empty()){
int now=q.front(); q.pop();
if(now==t) break;
for(int i=1;i<=m;i++){
if(!visit[i]&&MAP[now][i]){
q.push(i);
minn=min(minn,map[now][i]);//最小的rest
pre[i]=now; visit[i]=1;
}
}
}
if(pre[i]==-1) return 0;
return minn;
}
int EK(int S,int T){ //EK算法主体
int new_flow=0;//增广路的流量
int max_flow=0;//最大流
do{
new_flow=find(S,T);
update(T,new_flow);
max_flow+=new_flow;
}while(new_flow);
return max_flow;
}
恩，(EK)算法差不多就是这个样子。
(Dinic)算法
首先我们要知道几个重要的基本概念：
(1.cap[u][v]=-cap[v][u])
(2.∑(p∈E)cap[p][u]==∑(p∈E)cap[u][p])
而(Dinic)也是基于增广路的思想进行运算的,我们用另一种方式重申一遍增广路的基本步骤
1.找到一条从源点到汇点的路径，使得这条路径上任意一条边的残余流量(rest)>0，这条路径便称为增广路。
2.找到这条路径上最小的(rest)为(minrest)，然后将这条路径上的所有边的(rest)减去这个(minrest),对于我们建的反向边的(rest)都加上这个(minrest)。
重复此上的过程，直到再也找不到增广路，此时我们就找到了最大流。
然后在我们的(Dinic)算法中我们引入分层图的概念，具体就是对于每一个点，我们根据从源点开始的(BFS)序列，给每一个点分配一个(deep,)深度，然后我们进行不断的(DFS)寻找增广路，而每一次我们由(now)推出(to)必须保证(deep[to])==(deep[now])+(1;) 下面是(Dinic)的代码流程。
#define MAXN 100010
#define INF 0x7fffffff
int n,m,s,t;//n:点数，m:边数，s:源点，t:汇点
struct node{//前向星不解释
int from;
int to;
int next;
int rest;//每一条边的剩余流量
}edge[MAXN*100];
int head[MAXN],total=-1;
void add(int f,int t,int l){
total++;
edge[total].from=f;
edge[total].to=t;
edge[total].rest=l;
edge[total].next=head[f];
head[f]=total;
}
int deep[MAXN];//深度
queue<int> q;//BFS用队列
bool bfs(){//bfs用来寻找分层图，增广路
while(!q.empty()) q.pop();//清空队列
memset(deep,0,sizeof(deep));//清空深度
deep[s]=1; q.push(s);//处理源点
do{
int now=q.front(); q.pop();//取队首
for(int i=head[now];i!=-1;i=edge[i].next){
if(edge[i].rest&&!deep[edge[i].to]){
//如果这条边还有rest并且这个点还没有被发放deep
deep[edge[i].to]=deep[now]+1;
q.push(edge[i].to);//入队列接着bfs
}
}
}while(!q.empty());
if(deep[t]==0) return 0;
//当没有汇点的深度时，说明不存在分层图，也就没有增广路
else return 1; //有增广路，可以跑Dinic。
}
int dfs(int now,int flow){//now：当前节点，flow：当前流量
if(now==t||!flow) return flow;
int res=0;
for(int i=head[now];i!=-1;i=edge[i].next){
if(deep[edge[i].to]==deep[now]+1&&edge[i].rest){
//如果满足分层图并且rest不为0
int rest=dfs(edge[i].to,min(flow,edge[i].rest));
//接着向下dfs。
if(rest>0){//增广成功
edge[i].rest-=rest;//正向边减去剩余流量
edge[i^1].rest+=rest;//负向边加上剩余流量
res+=rest;
flow-=rest;
}
}
}
return res;//没有增广路的话，就返回0.
}
int Dinic(){
int ans=0; //用来记录最大流量
while(bfs()){
while(int d=dfs(s,INF))
ans+=d;
}
return ans;
}
然后我们可以在(Dinic)的(dfs)当中进行一个当前弧优化就是说：我们(DFS)的时候不从第一条边开始，用一个数组(cur)记录点(now)之前循环到了那一条边，就可以起到优化的效果，但是要注意：每一次在(Dinic)函数中建立完一次分层图都要把(cur)置为每一个点的第一条边。
#define MAXN 100010
#define INF 0x7fffffff
int n,m,s,t;//n:点数，m:边数，s:源点，t:汇点
struct node{//前向星不解释
int from;
int to;
int next;
int rest;//每一条边的剩余流量
}edge[MAXN*100];
int head[MAXN],total=-1;
void add(int f,int t,int l){
total++;
edge[total].from=f;
edge[total].to=t;
edge[total].rest=l;
edge[total].next=head[f];
head[f]=total;
}
int cur[MAXN];//这就是那个cur，用来当前弧优化
int deep[MAXN];//深度
queue<int> q;//BFS用队列
bool bfs(){//bfs用来寻找分层图，增广路
while(!q.empty()) q.pop();//清空队列
memset(deep,0,sizeof(deep));//清空深度
deep[s]=1; q.push(s);//处理源点
do{
int now=q.front(); q.pop();//取队首
for(int i=head[now];i!=-1;i=edge[i].next){
if(edge[i].rest&&!deep[edge[i].to]){
//如果这条边还有rest并且这个点还没有被发放deep
deep[edge[i].to]=deep[now]+1;
q.push(edge[i].to);//入队列接着bfs
}
}
}while(!q.empty());
if(deep[t]==0) return 0;
//当没有汇点的深度时，说明不存在分层图，也就没有增广路
else return 1; //有增广路，可以跑Dinic。
}
int dfs(int now,int flow){//now：当前节点，flow：当前流量
if(now==t||!flow) return flow;
int res=0;
for(int& i=cur[now];i!=-1;i=edge[i].next){
//这就是当前弧优化的主要部分，前面的&是为了让cur和i一起变化
if(deep[edge[i].to]==deep[now]+1&&edge[i].rest){
//如果满足分层图并且rest不为0
int rest=dfs(edge[i].to,min(flow,edge[i].rest));
//接着向下dfs。
if(rest>0){//增广成功
edge[i].rest-=rest;//正向边减去剩余流量
edge[i^1].rest+=rest;//负向边加上剩余流量
res+=rest;
flow-=rest;
}
}
}
return res;//没有增广路的话，就返回0.
}
int Dinic(){
int ans=0; //用来记录最大流量
while(bfs()){
for(int i=1;i<=n;i++)
cur[i]=head[i];//不要忘了重置
while(int d=dfs(s,INF))
ans+=d;
}
return ans;
}
最大流模板题
(color{purple}{Link})
下面放上的是洛谷P3376的网络流模板题，就是为了存个完整代码...
题目描述
如题，给出一个网络图，以及其源点和汇点，求出其网络最大流。
输入输出格式
输入格式：
第一行包含四个正整数N、M、S、T，分别表示点的个数、有向边的个数、源点序号、汇点序号。
接下来M行每行包含三个正整数ui、vi、wi，表示第i条有向边从ui出发，到达vi，边权为wi（即该边最大流量为wi）
输出格式：
一行，包含一个正整数，即为该网络的最大流。
输入样例#1：
4 5 4 3
4 2 30
4 3 20
2 3 20
2 1 30
1 3 40
输出样例#1：
50
样例说明：
题目中存在3条路径：
4-->2-->3，该路线可通过20的流量
4-->3，可通过20的流量
4-->2-->1-->3，可通过10的流量（边4-->2之前已经耗费了20的流量）
故流量总计20+20+10=50。输出50。
通过证明：
#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
#define MAXN 100010
#define INF 0x7fffffff
using namespace std;
int n,m,s,t;//n:点数，m:边数，s:源点，t:汇点
struct node{//前向星不解释
int from;
int to;
int next;
int rest;//每一条边的剩余流量
}edge[MAXN*100];
int head[MAXN],total=-1;
void add(int f,int t,int l){
total++;
edge[total].from=f;
edge[total].to=t;
edge[total].rest=l;
edge[total].next=head[f];
head[f]=total;
}
int cur[MAXN];//这就是那个cur，用来当前弧优化
int deep[MAXN];//深度
queue<int> q;//BFS用队列
bool bfs(){//bfs用来寻找分层图，增广路
while(!q.empty()) q.pop();//清空队列
memset(deep,0,sizeof(deep));//清空深度
deep[s]=1; q.push(s);//处理源点
do{
int now=q.front(); q.pop();//取队首
for(int i=head[now];i!=-1;i=edge[i].next){
if(edge[i].rest&&!deep[edge[i].to]){
//如果这条边还有rest并且这个点还没有被发放deep
deep[edge[i].to]=deep[now]+1;
q.push(edge[i].to);//入队列接着bfs
}
}
}while(!q.empty());
if(deep[t]==0) return 0;
//当没有汇点的深度时，说明不存在分层图，也就没有增广路
else return 1; //有增广路，可以跑Dinic。
}
int dfs(int now,int flow){//now：当前节点，flow：当前流量
if(now==t||!flow) return flow;
int res=0;
for(int& i=cur[now];i!=-1;i=edge[i].next){
//这就是当前弧优化的主要部分，前面的&是为了让cur和i一起变化
if(deep[edge[i].to]==deep[now]+1&&edge[i].rest){
//如果满足分层图并且rest不为0
int rest=dfs(edge[i].to,min(flow,edge[i].rest));
//接着向下dfs。
if(rest>0){//增广成功
edge[i].rest-=rest;//正向边减去剩余流量
edge[i^1].rest+=rest;//负向边加上剩余流量
res+=rest;
flow-=rest;
}
}
}
return res;//没有增广路的话，就返回0.
}
int Dinic(){
int ans=0; //用来记录最大流量
while(bfs()){
for(int i=1;i<=n;i++)
cur[i]=head[i];//不要忘了重置
while(int d=dfs(s,INF))
ans+=d;
}
return ans;
}
int main(){
scanf("%d%d%d%d",&n,&m,&s,&t);
for(int i=1;i<=n;i++) head[i]=-1;
for(int i=1;i<=m;i++){
int x,y,l;
scanf("%d%d%d",&x,&y,&l);
add(x,y,l);
add(y,x,0);
}
printf("%d",Dinic());
return 0;
}
最小费用最大流
最小费用最大流的意思其实也很简单，我们现在已经知道最大流是什么了，而我们知道网络流的可行流有很多，而最大流也是不只有一个，题目在每一条边上设定了两个属性：1.cap流量，2.cost费用，要我们输出所有最大流方案中的最小费用。而最小费用最大流和最大费用最大流统称费用流。那么接下来是最小费用最大流的完整的题目描述。
题目描述
如题，给出一个网络图，以及其源点和汇点，每条边已知其最大流量和单位流量费用，求出其网络最大流和在最大流情况下的最小费用。
输入输出格式
输入格式：
第一行包含四个正整数N、M、S、T，分别表示点的个数、有向边的个数、源点序号、汇点序号。
接下来M行每行包含四个正整数ui、vi、wi、fi，表示第i条有向边从ui出发，到达vi，边权为wi（即该边最大流量为wi），单位流量的费用为fi。
输出格式：
一行，包含两个整数，依次为最大流量和在最大流量情况下的最小费用。＃
大家还记得我们在讲解最大流的时候讲过一种叫做(EK)的算法吧，下面我们来回顾一下：
若一条从源点SS到汇点TT的路径上各条边的剩余容量都大于00，则称这条路径为一条增广路。显然，可以让一股流沿着增广路从SS流到TT，使网络的流量增大。
Edmonds-Karp 算法的思想就是不断用BFS寻找增广路，直至网络上不存在增广路为止。
在每轮寻找增广路的过程中，Edmonds-Karp 算法只考虑图中所有 (f(x,y)<c(x,y))的边，用(BFS)找到任意一条从(S)到(T)的路径，同时计算出路径上各边的剩余容量的最小值(minf)，则网络的流量就可以增加(minf)。
需要注意的是，当一条边的流量(f(x,y)>0)时，根据斜对称性质，它的反向边流量(f(x,y)<0)，此时必有(f(y,x)<c(y,x))。故(Edmonds)-(Karp)算法在 BFS时除了原图的边集(E)之外，还应该考虑遍历(E)中每条边的反向边。
在具体实现时，可以按照邻接表成对存储的技巧，把网络的每条有向边及其反向边存在邻接表下标相邻的两个位置，可以相互用xor1xor得到。并且每条边只记录剩余容量(c-f)即可。当一条边((x,y))流过大小为(e)的流时，令((x,y))的剩余流量减少(e),((y,x))的剩余流量增大(e)。
(Edmonds)-(Karp)算法的时间复杂度为(O(n⋅m^2))，在实际应用中则远远达不到这个上界，效率较高，一般能够处理 (10^3)至(10^4)规模的网络。
那么我们接下来要讲解的最小费用最大流也是利用(EK)算法来解决的，首先，我们沿着最短路进行增广，而路径长度自然就是路径上的费用，而我们建的反向边的费用是对应正向边的费用的相反数（为了保证过程可逆），而反向边的流量像往常一样依然是0。这里我们可以选择用(SPFA)或者是(Dijkstra)进行最短路，然后就是求解最短路的实际流量并修改相关数据，以便下一次在残余网络上继续进行增广。
说到这里可能会有些懵逼，不要急，我会先通过更简单易懂的语言来讲解，然后我们还会结合代码慢慢的讲。
其实我们要想：最小费用最大流比单纯的最大流多了什么？就是一个路径上的费用，那我们要解决的就是这个费用问题，那么我们要求得最小的费用要用的最好懒的方法是什么呢？当然就是最短路啊，我们知道(EK)算法有一个(BFS())函数，我们也知道(SPFA)和(Dijkstra)这种最短路求法也是(BFS)，那么我们就可以很愉快地将(BFS)函数转化为最短路的算法啦~。
下面我们结合着代码讲解一下：
首先我们来介绍一下下面要用到的变量的名称：
int n,m,s,t;
//n:点数,m:边数,s:起点,t:终点
int dist[MAXN],flow[MAXN];
//dist[i]:从s到i的最短路径长度(SPFA用)
//flow:流量
bool inque[MAXN];;
//inque[i]表示点i是否在队列里面。
int pre[MAXN],rest[MAXN];
//pre[i]:i的前驱节点
//rest[i]第i条边的剩余流量
int max_flow; int min_spent;
//max_flow:最大流
//min_spent:最小花费
queue<int> q;
//队列
加边没有什么问题。
struct node{
int from;
int to;
int len;
//费用
int cap;
//流量
int next;
}edge[MAXN];
int head[MAXN],total=-1;
//要注意将这里的head[MAXN]和total都置为-1！Yeasion在这上面摔了好几次
void add(int f,int t,int l,int c){
total++;
edge[total].from=f;
edge[total].to=t;
edge[total].len=l;
edge[total].cap=c;
edge[total].next=head[f];
head[f]=total;
}
然后主函数颇为稀松，但是要注意建反向边的时候要将流量置为0，将费用置为原正向边的相反数（(edge[i].cap=-edge[i)^(1].cap)）。
int main(){
scanf("%d%d%d%d",&n,&m,&s,&t);
for(int i=1;i<=n;i++) head[i]=-1;
for(int i=1;i<=m;i++){
int x; int y; int l; int c;
scanf("%d%d%d%d",&x,&y,&c,&l);
add(x,y,l,c); add(y,x,0,-c);
//注意加反向边要注意的两点哦
} Edmonds_Karp(s,t);
printf("%d %d",max_flow,min_spent);
return 0;
}
接下来就是(EK)函数了，我们在这个函数里面传入了begin和end的参数，如果大家不想传递的话是可以省略掉的
void Edmonds_Karp(int begin,int end){
while(SPFA(begin,end)){
//寻找增广路
int now=end;
max_flow+=rest[end];
//将最大流加上最小流量
min_spent+=dist[end]*rest[end];
//将最小花费加上从s开始到t的最小路径长*到t的最小流量
while(now!=begin){
edge[last[now]].cap-=rest[end];
//正向边减去最小流量
edge[last[now]^1].cap+=rest[end];
//反向边加上最小流量
now=pre[now];
//设置前趋
}
}
}
最后是SPFA的函数，在这里面我们主要进行的操作有三个：1.找出最短路。当然这个最短路的前提条件是每一条边都有剩余流量edge[i].cap，不然没有任何意义。2.寻找最小流量rest。3.寻找每一个点的前驱。然后返回的条件依然是看有没有找到增广路，就是看t的前驱有没有被更新如果没有，自然就是没有任何一条路能够到达t节点。
bool SPFA(int begin,int end){
while(!q.empty()) q.pop();
memset(dist,127,sizeof(dist));
memset(inque,0,sizeof(inque));
memset(rest,127,sizeof(rest));
//每一次的SPFA不要忘了将所有的变量还原
//但千万别还原pre qwq
q.push(begin); inque[begin]=1;
//入队s点 ，初始化
pre[end]=-1; dist[begin]=0;
//SPFA过程
while(!q.empty()){
int now=q.front();q.pop();
inque[now]=false;
for(int i=head[now];i!=-1;i=edge[i].next)
if(edge[i].cap>0)//这里就是网络流的部分了，首先这条边如果没有了残余流量我们肯定不跑
if(dist[edge[i].to]>dist[now]+edge[i].len){
dist[edge[i].to]=dist[now]+edge[i].len;//SPFA松弛操作
pre[edge[i].to]=now;//更新edge[i].to的前驱为now
rest[edge[i].to]=min(rest[now],edge[i].cap);
//寻找最小的流量
if(!inque[edge[i].to]){//入队，继续SPFA
q.push(edge[i].to);
inque[edge[i].to]=1;
}
}
}
if(pre[end]==-1) return 0;
//如果没有找到t即：t的前驱依然是不存在的-1，则没有增广路，返回0，停止EK
else return 1; //继续进行EK
}
下面是(EK)的算法代码：
#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
#define MAXN 100010
#define INF 0x7fffffff
#define ll long long
using namespace std;
int n,m,s,t;
struct node{
int from;
int to;
int len;
int cap;
int next;
}edge[MAXN];
int head[MAXN],total=-1;
void add(int f,int t,int l,int c){
total++;
edge[total].from=f;
edge[total].to=t;
edge[total].len=l;
edge[total].cap=c;
edge[total].next=head[f];
head[f]=total;
}
int dist[MAXN],flow[MAXN];
bool inque[MAXN]; int last[MAXN];
int pre[MAXN],rest[MAXN];
int max_flow; int min_spent;
queue<int> q;
bool SPFA(int begin,int end){
while(!q.empty()) q.pop();
memset(dist,127,sizeof(dist));
memset(inque,0,sizeof(inque));
memset(rest,127,sizeof(rest));
q.push(begin); inque[begin]=1;
pre[end]=-1; dist[begin]=0;
while(!q.empty()){
int now=q.front();q.pop();
inque[now]=false;
for(int i=head[now];i!=-1;i=edge[i].next)
if(edge[i].cap>0)
if(dist[edge[i].to]>dist[now]+edge[i].len){
dist[edge[i].to]=dist[now]+edge[i].len;
pre[edge[i].to]=now;
last[edge[i].to]=i;
rest[edge[i].to]=min(rest[now],edge[i].cap);
if(!inque[edge[i].to]){
q.push(edge[i].to);
inque[edge[i].to]=1;
}
}
}
if(pre[end]==-1) return 0;
else return 1;
}
void Edmonds_Karp(int begin,int end){
while(SPFA(begin,end)){
int now=end;
max_flow+=rest[end];
min_spent+=dist[end]*rest[end];
while(now!=begin){
edge[last[now]].cap-=rest[end];
edge[last[now]^1].cap+=rest[end];
now=pre[now];
}
}
}
int main(){
scanf("%d%d%d%d",&n,&m,&s,&t);
for(int i=1;i<=n;i++) head[i]=-1;
for(int i=1;i<=m;i++){
int x; int y; int l; int c;
scanf("%d%d%d%d",&x,&y,&c,&l);
add(x,y,l,c); add(y,x,0,-c);
} Edmonds_Karp(s,t);
printf("%d %d",max_flow,min_spent);
return 0;
}