网络流算法

求最大流的过程，就是不断找到一条源到汇的路径，然后构建残余网络，

再在残余网络上寻找新的路径，使总流量增加，然后形成新的残余网络，

再寻找新路径…..直到某个残余网络上找不到从源到汇的路径为止，最

大流就算出来了。

每次寻找新流量并构造新残余网络的过程，就叫做寻找流量的“增广路径”，也叫“增广”

各种算法的不同之处，也就是在寻找一条从源到汇的过程中进行优化而已

1) DFS 

直接用dfs寻找增广路径，直到找不到路

这种算法十分简单，但复杂度高

本来2次就行了，但有可能要200次

2）Edmonds-Karp 最短增广路算法(BFS)  O(n*m*m)  (n是点数，m是边数）

利用bfs寻找一条增广路径

#include<iostream>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
const int maxn=300;
const int INF=(1<<30);
int G[maxn][maxn];
int prev[maxn];    //记录前驱节点，记录增广路径 
bool vis[maxn]; 
int Augment(int s,int t,int m)      //增广 
{
	queue<int> Q;
	bool isFound=false;  //标记是否找到了增广路 
	memset(vis,false,sizeof(vis));
	memset(prev,0,sizeof(prev));
	
	Q.push(s);
	vis[s]=true;
	while(!Q.empty())
	{
		int u=Q.front(); Q.pop();
		if(u==t) {    //找到增广路径了 
			isFound=true;
			break;
		}
		for(int v=1;v<=m;v++)     //注意是从1开始计数的 
		if(G[u][v]>0&&!vis[v]){
			prev[v]=u;
			vis[v]=1;
			Q.push(v); 
		}
	}
		
	if(!isFound) return 0;   //无路可走 
	int MinFlow=INF;   

	int u=m;
	while(u!=s){    //计算途中最小流 
		MinFlow=min(MinFlow,G[prev[u]][u]);
		u=prev[u];
	}
	
	u=m;
	while(u!=s){
		G[prev[u]][u]-=MinFlow;  //更新途径路的流量 
		G[u][prev[u]]+=MinFlow;  //加上反向边 
		u=prev[u];
	}
	return MinFlow;
}
int main()
{
	int n,m;
	while(cin>>n>>m)
	{
		int u,v,w;
		memset(G,0,sizeof(G));
		for(int i=0;i<n;i++){
			cin>>u>>v>>w;   //u-->v 上限是w 
			G[u][v]+=w;    //可能有多条边 
		}
		int MaxFlow=0;
		int aug;
		while(aug=Augment(1,m,m))  //(start,terminal,Node's number)
			MaxFlow+=aug;     //加上每次增广的流 
		cout<<MaxFlow<<endl; 
	}
	return 0;	
} 

3)Dinic 快速网络流算法(BFS+DFS)   O(n*n*m) (n是点数，m是边数）

因为上述算法都是找到一条从源到汇的路径并进行增广后，重新回到源点继续寻找路径

但Dinic并不是从头找

Dinic优点如下：

1）结合BFS快速的优点，先用BFS将源点到汇点分层，每次DFS时，只能走到下一层结点

2）因为每次增广后增广路径上至少有一条路径流量上限为0，所以直接返回到增广路径中流量为0的起点进行增广，如果有多条增广路径的流量为0，就选择最上面那一条

#include<iostream>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
const int maxn=300;
const int INF=(1<<30);
int m,n;   
int G[maxn][maxn];
bool vis[maxn]; 
int layer[maxn];    //记录层次 
bool getLayer(int s,int t,int m)    //分层 
{
	queue<int> Q;
	memset(layer,0,sizeof(layer));
	
	layer[s]=1;
	Q.push(s);
	while(!Q.empty())
	{
		int u=Q.front(); Q.pop();
		for(int v=1;v<=m;v++)
		if(G[u][v]>0&&!layer[v]){
			layer[v]=layer[u]+1;
			if(v==t) return true;  //一旦到终点m就不必分层了 
			Q.push(v);
		}	
	}
	return false;
}
int Dinic(int s,int t,int m)
{
	int MaxFlow=0;
	while(getLayer(s,t,m))
	{
		deque<int> DQ;   //保存路径 
		memset(vis,0,sizeof(vis));
		vis[s]=1;
		DQ.push_back(1);
		while(!DQ.empty())
		{
			int u=DQ.back();
			if(u==t)          //找到增广路径了，便找出最小流，更新网络流，添加反向边 
			{
				int MinFlow=INF;  //最小流 
				int pMin;         //最小流的上一个节点位置 
				for(int i=1;i<DQ.size();i++)
				{
					int u=DQ[i-1];
					int v=DQ[i];
					if(G[u][v]>0&&MinFlow>G[u][v]) //找出最小流 
					{
						MinFlow=G[u][v];
						pMin=u; 
					} 
				}
				MaxFlow+=MinFlow;   //累加到最大流 
				for(int i=1;i<DQ.size();i++)
				{
					int u=DQ[i-1];
					int v=DQ[i];
					G[u][v]-=MinFlow; //更新最小流 
					G[v][u]+=MinFlow; //添加反向边 
				}
				
				while(!DQ.empty()&&DQ.back()!=pMin){  //退栈到PMin，回溯继续找增广路径 
					vis[DQ.back()]=0;
					DQ.pop_back();
				}
				continue;
			}
			int ok=0;
			for(int v=1;v<=m;v++)
			if(G[u][v]>0&&!vis[v]&&layer[v]==layer[u]+1)  //只能走到下一层 
			{
				ok=1;
				vis[v]=1;
				DQ.push_back(v);
				break;	
			}
			
			if(!ok) DQ.pop_back();  //不能走就pop，换一条路走	
		} 
	}
	return MaxFlow; 
}
int main()
{
	while(cin>>n>>m)   //从1~m的最大流 //m为顶点数，n为边数 
	{
		int u,v,w;
		memset(G,0,sizeof(G));
		for(int i=0;i<n;i++){
			cin>>u>>v>>w;     //u-->v  上限是w 
			G[u][v]+=w;       //可能有多条边 
		}
		cout<<Dinic(1,m,m)<<endl; 
	}
	return 0;	
}