网络流增广路Edmonds-Karp算法 与 Dinic算法

https://www.luogu.org/problemnew/show/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

说明

时空限制：1000ms,128M

数据规模：

对于30%的数据：N<=10，M<=25

对于70%的数据：N<=200，M<=1000

对于100%的数据：N<=10000，M<=100000

样例说明：

题目中存在3条路径：

4-->2-->3，该路线可通过20的流量

4-->3，可通过20的流量

4-->2-->1-->3，可通过10的流量（边4-->2之前已经耗费了20的流量）

故流量总计20+20+10=50。输出50。

EK

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int MAXN = 10000;
const int MAXM = 100000;
const int INF = 1E9;
typedef long long LL;
typedef double DB;
inline int get(){
	char c;
	while((c = getchar()) < '0' || c > '9');
	int cnt = c - '0';
	while((c = getchar()) >= '0' && c <= '9') cnt = cnt * 10 + c - '0';
	return cnt;
}
int N,M,S,T;
struct edge{
	int from,to,cap;
	edge(int u,int v,int x): from(u),to(v),cap(x){}
};

vector<edge> e;
vector<int> g[MAXN + 10];
int p[MAXN + 10];
int a[MAXN + 10];
void add_edge(int u,int v,int x){
	e.push_back(edge(u,v,x));
	e.push_back(edge(v,u,0));
	int m = e.size();
	g[u].push_back(m - 2);
	g[v].push_back(m - 1);
}
int max_flow(int Sat,int End){
	int flow = 0;
	while(1){
		memset(a,0,sizeof(a));
		queue<int> q;
		q.push(Sat);
		a[Sat] = INF;
		while(!q.empty()){
			int f = q.front(); q.pop();
			for(int i = 0; i < g[f].size(); i ++){
				edge k = e[g[f][i]];
				if(!a[k.to] && k.cap > 0){
					a[k.to] = min(k.cap,a[f]);
					p[k.to] = g[f][i];
					q.push(k.to);
				}			
			}
			if(a[End]) break;
		}
		if(!a[End]) break;
		for(int i = End; i != Sat; i = e[p[i]].from){
			e[p[i]].cap -= a[End];
			e[p[i]^1].cap += a[End];
		}
		flow += a[End];
	}
	return flow;
}
int main(){
	#ifdef lwy
		freopen("1.txt","r",stdin);
/*	#else
		freopen(".in","r",stdin);
		freopen(".out","w",stdout);*/
	#endif
	N = get(); M = get(); S = get(); T = get();
	for(int i = 1; i <= M; i ++){
		int u,v,x;
		u = get(); v = get(); x = get();
		add_edge(u,v,x);
	}
	printf("%d",max_flow(S,T));
	return 0;
}

dinic

用bfs建立层次图（按深度），流量为0的边不加以考虑，这样每次bfs完如果能到T，那么就存在增广路。

以bfs建立的层次图进行dfs，寻找增广路。

重复上述过程直到找不到增广路，即求出最大流。

dfs的终止条件是找到汇点或 a = 0 （a = 0 时说明已经增广了一条路，且之后的增广不能再通过这条路，如果继续增广，后面的搜索都是无效的，所以要回溯更新每条边的残量，直到更新到最小残量时则继续搜索，因为a（最小残量）已经更新，当a = 0 时会再次回溯)。

这里cur[] 的作用是记录上次考虑的弧，这样回溯后再进行搜索的时候就可以避免重复搜索。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
const int MAXN = 100000;
const int INF = 1E9;
typedef long long LL;
typedef double DB;
inline int get(){
	char c;
	while((c = getchar()) < '0' || c > '9');
	int cnt = c - '0';
	while((c = getchar()) >= '0' && c <= '9') cnt = cnt * 10 + c - '0';
	return cnt;
}
struct edge{
	int fr,to,res;
	edge(int u,int v,int f):fr(u),to(v),res(f){};
}; 
vector<edge> e;
vector<int> g[MAXN + 10];
int dep[MAXN + 10];
int cur[MAXN + 10];
bool vis[MAXN + 10];
int N,M,S,T,maxf;
inline bool bfs(){
	memset(vis,0,sizeof(vis));
	queue<int> q;
	q.push(S);
	dep[S] = 0; vis[S] = 1;
	while(!q.empty()){
		int f = q.front(); q.pop();
		for(int i = 0; i < g[f].size(); i ++){
			edge k = e[g[f][i]];
			if(!vis[k.to] && k.res > 0){
				vis[k.to] = true;
				dep[k.to] = dep[f] + 1;
				q.push(k.to);
			}
		}
	}
	return vis[T];
}
inline int dfs(int x,int a){
	if(x == T || a == 0) return a;
	int flowt = 0,flown;
	for(int& i = cur[x]; i < g[x].size(); i ++){
		edge k = e[g[x][i]];
		if(dep[x] + 1 == dep[k.to]){//
			flown = dfs(k.to,min(a,k.res));
			if(flown > 0){
				e[g[x][i]].res -= flown;
				e[g[x][i]^1].res += flown;
				flowt += flown;
				a -= flown;
				if(a == 0) break;
			}
		}
	}
	return flowt;
}
int main(){
	#ifdef lwy
		freopen("1.txt","r",stdin);
/*	#else
		freopen(".in","r",stdin);
		freopen(".out","w",stdout); */ 
	#endif
	N = get(); M = get(); S = get(); T = get();
	for(int i = 1; i <= M; i ++){
		int u,v,f;
		u = get(); v = get(); f = get();
		e.push_back(edge(u,v,f));
		e.push_back(edge(v,u,0));
		int m = e.size();
		g[v].push_back(m - 1);
		g[u].push_back(m - 2);
	}
	while(bfs()){
		memset(cur,0,sizeof(cur));
		maxf += dfs(S,INF);
	}
	printf("%d",maxf);
	return 0;
}