最大流（网络流、最小割）（待填）

问题描述

给定一个图，设有n个点和m条边，每条边有一定的容量，n个点中有一个源点，一个汇点，源点释放流量，汇点接收流量，求汇点最大接收流量。
最大流模板
预流推进模板

解决方案

EdmondsKarp算法

以下是来源于算法竞赛入门经典中最大流的描述：

存储边

首先我们思考怎么存储边，显然使用结构体，里面要有以下元素

struct Edge{
	int from,to,cap,flow;
	Edge(int u,int v,int c,int f):from(u),to(v),cap(c),flow(f){}
};

增加边

然后是增加边操作

void AddEdge(int from,int to,int cap){
		edges.push_back(Edge(from,to,cap,0));		//有容量的边 
		edges.push_back(Edge(to,from,0,0));			//0容量的边 
		m=edges.size();							//方便记录边的序号 
		G[from].push_back(m-2);					//表示有容量的边 
		G[to].push_back(m-1);				//表示没容量的边 
	}

这里需要添加两条边，因为增广过程需要用到容量为0的反向边
下面是反向边作用的具体例子
关于反向边

初始化

n代表图中点的个数（包括源汇点），m在结构体中为一个迭代器
注意，这是在一个结构体中写的，所以要用this
你可以在下面看到全部代码。
初始化只传n值，初始化G数组

	int n,m;
	vector<Edge>edges;
	vector<int>G[maxn];	//记录G[i][j]结点i的第j条边在e里的标号 
	int a[maxn];		//表示起点到i的可改进量，即可加量 
	int p[maxn];		//路径记录，方便流量变化 
		
	void init(int n){
		this->n=n;
		for(int i=0;i<n;i++)G[i].clear();	//此处是从0开始的下标 
		edges.clear();						
	}

最大流求解

int Maxflow(int s,int t){
		int flow=0;
		for(;;){
			memset(a,0,sizeof(a));		//可改进量初始化 
			queue<int>Q;			//进入点序号 
			Q.push(s);		// 
			a[s]=INF;		//原点可改进量置为最大 
			while(!Q.empty()){
				int x=Q.front();Q.pop();
				for(int i=0;i<G[x].size();i++){
					Edge& e=edges[G[x][i]];		//开始枚举x所连边 
					if(!a[e.to]&&e.cap>e.flow){	//如果e.to没被遍历并且还可以有流量流入 
						p[e.to]=G[x][i];			//那么记录e.to前驱 
						a[e.to]=min(a[x],e.cap-e.flow);	// 
						Q.push(e.to); 
					}
				}
				if(a[t])break;
				
			}
			if(!a[t])break;
			for(int u=t;u!=s;u=edges[p[u]].from){
				edges[p[u]].flow+=a[t];
				edges[p[u]^1].flow-=a[t];
			}
			flow+=a[t];
		}

		return flow;
	}

传入原点、汇点，开始无限次bfs，每一次dfs都能找到一条增广路，如果找不到增广路了，那就结束。
每一次找的增广路不一定是最优的，这是靠多次查找来确保正确性。
因此这个算法还可以优化。
此算法复杂度为O($n{m}^2$)

EdmondsKarp完整代码

#include<bits/stdc++.h>
using namespace std;
#define maxn 100010
#define int long long
#define INF 1e18
struct Edge{
	int from,to,cap,flow;
	Edge(int u,int v,int c,int f):from(u),to(v),cap(c),flow(f){}
};
struct EdmondsKarp{
	int n,m;
	vector<Edge>edges;
	vector<int>G[maxn];	//记录G[i][j]结点i的第j条边在e里的标号 
	int a[maxn];		//表示起点到i的可改进量，即可加量 
	int p[maxn];		//路径记录，方便流量变化 
		
	void init(int n){
		this->n=n;
		for(int i=0;i<n;i++)G[i].clear();	//此处是从0开始的下标 
		edges.clear();						
	}
	
	void AddEdge(int from,int to,int cap){
		edges.push_back(Edge(from,to,cap,0));		//有容量的边 
		edges.push_back(Edge(to,from,0,0));			//0容量的边 
		m=edges.size();							//方便记录边的序号 
		G[from].push_back(m-2);					//表示有容量的边 
		G[to].push_back(m-1);				//表示没容量的边 
	}
	int Maxflow(int s,int t){
		int flow=0;
		for(;;){
			memset(a,0,sizeof(a));		//可改进量初始化 
			queue<int>Q;			//进入点序号 
			Q.push(s);		// 
			a[s]=INF;		//原点可改进量置为最大 
			while(!Q.empty()){
				int x=Q.front();Q.pop();
				for(int i=0;i<G[x].size();i++){
					Edge& e=edges[G[x][i]];		//开始枚举x所连边 
					if(!a[e.to]&&e.cap>e.flow){	//如果e.to没被遍历并且还可以有流量流入 
						p[e.to]=G[x][i];			//那么记录e.to前驱 
						a[e.to]=min(a[x],e.cap-e.flow);	// 
						Q.push(e.to); 
					}
				}
				if(a[t])break;
				
			}
			if(!a[t])break;
			for(int u=t;u!=s;u=edges[p[u]].from){
				edges[p[u]].flow+=a[t];
				edges[p[u]^1].flow-=a[t];
			}
			flow+=a[t];
		}

		return flow;
	}
}EK;

signed main(){
	int n,s,m,t;
	cin>>n>>m>>s>>t;
//	cout<<INF<<endl;
	int u,v,w;
	EK.init(n);
	for(int i=0;i<m;i++){
//		cout<<i<<" "<<EK.m<<endl;
		cin>>u>>v>>w;
		u--;
		v--;
		EK.AddEdge(u,v,w);
	}
	cout<<EK.Maxflow(s-1,t-1);
	return 0;
} 
/*
6 6 1 6 
1 2 2
1 3 3
2 3 4 
3 5 5
2 5 6
5 6 7 
*/ 

dinic算法