初步了解网络流

网络流 ———— 从零开始（的异世界）

更好的阅读体验

最大流

首先，我们要知道什么是网络流，我们可以类比水流在水管里面的流动，假设在一个类似于有向图中的水管道中，有一个自来水厂 $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$ 算法。

Copy
#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$ 的代码流程。

Copy
#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$ 置为每一个点的第一条边。

Copy
#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。
通过证明：

Copy
#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$ 中每条边的反向边。

在具体实现时，可以按照邻接表成对存储的技巧，把网络的每条有向边及其反向边存在邻接表下标相邻的两个位置，可以相互用xor\1xor得到。并且每条边只记录剩余容量 $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$ 函数转化为最短路的算法啦~。
下面我们结合着代码讲解一下：
首先我们来介绍一下下面要用到的变量的名称：

Copy
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;
//队列

加边没有什么问题。

Copy
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$ ）。

Copy
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的参数，如果大家不想传递的话是可以省略掉的

Copy
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节点。

Copy
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$ 的算法代码：

Copy
#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;
}

posted @ 2018-07-26 21:14 Sue_Shallow 阅读(440) 评论(0) 收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

阅读排行：
· 用c#从头写一个AI agent，实现企业内部自然语言数据统计分析
· 三维装箱问题（3D Bin Packing Problem, 3D-BPP）
· Windows上，10分钟构建一个本地知识库
· Java虚拟机代码是如何一步一步变复杂且难以理解的？
· 凯亚物联网平台如何通过MQTT网络组件接入设备

Sue Shallow

Secretly in love with your fragrant eyes.

初步了解网络流

网络流 ———— 从零开始（的异世界）

更好的阅读体验

最大流

1： $EK$ 算法 ( $Edmonds-Karp$ )

$Dinic$ 算法

最大流模板题

题目描述

最小费用最大流

一行，包含两个整数，依次为最大流量和在最大流量情况下的最小费用。＃

公告

最新随笔

我的标签

随笔档案 (60)

文章档案 (3)

Sue Shallow

Secretly in love with your fragrant eyes.

初步了解网络流

网络流 ———— 从零开始（的异世界）

更好的阅读体验

最大流

1：EKEKEK算法 (Edmonds−KarpEdmonds−KarpEdmonds-Karp)

DinicDinicDinic算法

最大流模板题

题目描述

最小费用最大流

一行，包含两个整数，依次为最大流量和在最大流量情况下的最小费用。＃

公告

最新随笔

我的标签

随笔档案 (60)

文章档案 (3)

1： $EK$ 算法 ( $Edmonds-Karp$ )

$Dinic$ 算法