最大流的含义，就是说从源点到经过的所有路径的最终到达汇点的所有流量和
残余网络 增广路径 反向弧
观察下图-4，这种状态下它的残余网络如图-5所示：
也许现在你已经知道什么是残余网络了，对于已经找到一条从S 到T的路径的网络中，只要在这条路径上，把C(u,v)的值更新为C(u,v)-P(u,v)，并且添加反向弧C(v,u)。对应的增广路径Path为残留网络上从S到T的一条简单路径。图-4中S，A，C，T就是一条增广路径，当然还有S，B，C，T。
此外在未做任何操作之前，原始的有向图也是一个残余网络，它仅仅是未做任何更新而已。
Edmonds-Karp算法。
算法流程如下：
设队列Q：存储当前未访问的节点，队首节点出队后，成为已检查的标点；
Path数组：存储当前已访问过的节点的增广路径；
Flow数组：存储一次BFS遍历之后流的可改进量；
Repeat:
Path清空；
源点S进入Path和Q，Path[S]<-0，Flow[S]<-+∞；
While Q非空 and 汇点T未访问 do
Begin
队首顶点u出对；
For每一条从u出发的弧(u,v) do
If v未访问 and 弧(u,v) 的流量可改进；
Then Flow[v]<-min(Flow[u],c[u][v]) and v入队 and Path[v]<-u；
End while
If(汇点T已访问)
Then 从汇点T沿着Path构造残余网络；
Until 汇点T未被访问
EK算法的核心
反复寻找源点s到汇点t之间的增广路径，若有，找出增广路径上每一段[容量-流量]的最小值delta，若无，则结束。
在寻找增广路径时，可以用BFS来找，并且更新残留网络的值(涉及到反向边)。
而找到delta后，则使最大流值加上delta，更新为当前的最大流值。
白书上的图
b图表示了一条增广路，改变流量为4
只要残量网络中存在增广路，流量就可以增大。如果增广路不存在，则当前流就是最大流。
案例：
这么一个图，求源点1，到汇点4的最大流
代码：
#include <iostream> #include <queue> #include<string.h> using namespace std; #define arraysize 201 int maxData = 0x7fffffff; int capacity[arraysize][arraysize]; //记录残留网络的容量 int flow[arraysize]; //标记从源点到当前节点实际还剩多少流量可用 int pre[arraysize]; //标记在这条路径上当前节点的前驱,同时标记该节点是否在队列中 int n,m; queue<int> myqueue; int BFS(int src,int des) { int i,j; while(!myqueue.empty()) //队列清空 myqueue.pop(); for(i=1;i<m+1;++i) { pre[i]=-1; } pre[src]=0; flow[src]= maxData; myqueue.push(src); while(!myqueue.empty()) { int index = myqueue.front(); myqueue.pop(); if(index == des) //找到了增广路径 break; for(i=1;i<m+1;++i) { if(i!=src && capacity[index][i]>0 && pre[i]==-1) { pre[i] = index; //记录前驱 flow[i] = min(capacity[index][i],flow[index]); //关键：迭代的找到增量 myqueue.push(i); } } } if(pre[des]==-1) //残留图中不再存在增广路径 return -1; else return flow[des]; } int maxFlow(int src,int des) { int increasement= 0; int sumflow = 0; while((increasement=BFS(src,des))!=-1) { int k = des; //利用前驱寻找路径 while(k!=src) { int last = pre[k]; capacity[last][k] -= increasement; //改变正向边的容量 capacity[k][last] += increasement; //改变反向边的容量 k = last; } sumflow += increasement; } return sumflow; } int main() { int i,j; int start,end,ci; while(cin>>n>>m) { memset(capacity,0,sizeof(capacity)); memset(flow,0,sizeof(flow)); for(i=0;i<n;++i) { cin>>start>>end>>ci; if(start == end) //考虑起点终点相同的情况 continue; capacity[start][end] +=ci; //此处注意可能出现多条同一起点终点的情况 } cout<<maxFlow(1,m)<<endl; } return 0; }
显而易见capacity存变的流量，进行ek求解
对于BFS找增广路：
1. flow[1]=INF，pre[1]=0;
源点1进队列，开始找增广路，capacity[1][2]=40>0，则flow[2]=min(flow[1],40)=40;
capacity[1][4]=20>0,则flow[4]=min(flow[1],20)=20;
capacity[2][3]=30>0,则flow[3]=min(folw[2]=40，30)=30；
capacity[2][4]=30,但是pre[4]=1(已经在capacity[1][4]这遍历过4号点了)
capacity[3][4].....
当index=4（汇点），结束增广路的寻找
传递回increasement（该路径的流），利用前驱pre寻找路径
路径也自然变成了这样：
2.flow[1]=INF，pre[1]=0;
源点1进队列，开始找增广路，capacity[1][2]=40>0，则flow[2]=min(flow[1],40)=40;
capacity[1][4]=0!>0,跳过
capacity[2][3]=30>0,则flow[3]=min(folw[2]=40，30)=30；
capacity[2][4]=30,pre[4]=2，则flow[2][4]=min(flow[2]=40,20)=20;
capacity[3][4].....
当index=4（汇点），结束增广路的寻找
传递回increasement（该路径的流），利用前驱pre寻找路径
图也被改成
接下来同理
这就是最终完成的图，最终sumflow=20+20+10=50（这个就是最大流的值）
PS，为什么要有反向边呢？
我们第一次找到了1-2-3-4这条增广路，这条路上的delta值显然是1。于是我们修改后得到了下面这个流。（图中的数字是容量）
这时候(1,2)和(3,4)边上的流量都等于容量了，我们再也找不到其他的增广路了，当前的流量是1。
但这个答案明显不是最大流，因为我们可以同时走1-2-4和1-3-4，这样可以得到流量为2的流。
那么我们刚刚的算法问题在哪里呢？问题就在于我们没有给程序一个”后悔”的机会，应该有一个不走(2-3-4)而改走(2-4)的机制。那么如何解决这个问题呢？回溯搜索吗？那么我们的效率就上升到指数级了。
而这个算法神奇的利用了一个叫做反向边的概念来解决这个问题。即每条边(I,j)都有一条反向边(j,i)，反向边也同样有它的容量。
我们直接来看它是如何解决的：
在第一次找到增广路之后，在把路上每一段的容量减少delta的同时，也把每一段上的反方向的容量增加delta。即在Dec(c[x,y],delta)的同时，inc(c[y,x],delta)
我们来看刚才的例子，在找到1-2-3-4这条增广路之后，把容量修改成如下
这时再找增广路的时候，就会找到1-3-2-4这条可增广量，即delta值为1的可增广路。将这条路增广之后，得到了最大流2。
那么，这么做为什么会是对的呢？我来通俗的解释一下吧。
事实上，当我们第二次的增广路走3-2这条反向边的时候，就相当于把2-3这条正向边已经是用了的流量给”退”了回去，不走2-3这条路，而改走从2点出发的其他的路也就是2-4。（有人问如果这里没有2-4怎么办，这时假如没有2-4这条路的话，最终这条增广路也不会存在，因为他根本不能走到汇点）同时本来在3-4上的流量由1-3-4这条路来”接管”。而最终2-3这条路正向流量1，反向流量1，等于没有流量。
这就是这个算法的精华部分，利用反向边，使程序有了一个后悔和改正的机会。而这个算法和我刚才给出的代码相比只多了一句话而已。
至此，最大流Edmond-Karp算法介绍完毕。
部分转载自http://www.cnblogs.com/zsboy/archive/2013/01/27/2878810.html
另外注意最大流的题目中两点之间的路径往往是不唯一的
有个水池点1，一条溪流点n，n个节点，m条路径，问溪流到水池的最大流
最大流模板题
DFS写法
#include<iostream> #include<cstring> #include<cstdio> #include<algorithm> #include<queue> #include<vector> using namespace std; const int maxn = 220; const int maxm = 220; const int inf = 0x7fffffff; struct edge { int to,cap,rev; }; vector<edge>v[maxm]; bool used[maxn]; void addedge(int from,int to,int cap) { v[from].push_back((edge){to,cap,v[to].size()}); v[to].push_back((edge){from,0,v[from].size()-1}); } int dfs(int s,int t,int f) { if(s==t) return f; used[s]=true; for(int i=0;i<v[s].size();i++) { edge &tmp = v[s][i]; if(!used[tmp.to] && tmp.cap>0) { int d=dfs(tmp.to,t,min(f,tmp.cap)); if(d>0) { tmp.cap-=d; v[tmp.to][tmp.rev].cap+=d; return d; } } } return 0; } int max_flow(int s,int t) { int flow=0; for(;;) { memset(used,false,sizeof(used)); int f=dfs(s,t,inf); if(f==0) return flow; flow+=f; } } int main() { int n,m; while(~scanf("%d%d",&n,&m)) { for(int i=0;i<=n;i++)v[i].clear(); for(int i=0;i<n;i++) { int x,y,z; scanf("%d%d%d",&x,&y,&z); addedge(x,y,z); } printf("%d\n",max_flow(1,m)); } }
BFS标准写法
#include<iostream> #include<cstdio> #include<queue> #include<cstring> using namespace std; #define maxn 220 #define inf 0x7fffffff int cap[maxn][maxn]; int path[maxn]; bool vis[maxn]; int flow[maxn]; queue<int>q; int bfs(int n) { int st=1,en=n; memset(path,-1,sizeof(path)); memset(vis,false,sizeof(vis)); while(!q.empty())q.pop(); q.push(st); path[st]=0; vis[st]=true; flow[st]=inf; while(!q.empty()) { int index=q.front(); q.pop(); if(index==en) { return flow[en]; } for(int i=1;i<=n;i++) { if(!vis[i]&&cap[index][i]>0) { vis[i]=true; path[i]=index; flow[i]=min(flow[index],cap[index][i]); q.push(i); } } } return -1; } int max_flow(int n) { int sum=0; for(;;) { int tmp=bfs(n); if(tmp==-1)return sum; int en=n; while(path[en]) { int last=path[en]; cap[last][en]-=tmp;//正向 cap[en][last]+=tmp;//反向 en=path[en]; } sum+=tmp; } } int main() { int n,m; while(~scanf("%d%d",&m,&n)) { memset(cap,0,sizeof(cap)); int st,en,c; while(m--) { scanf("%d%d%d",&st,&en,&c); cap[st][en]+=c; } printf("%d\n",max_flow(n)); } return 0; }
最小割
http://www.cnblogs.com/kane0526/archive/2013/02/27/2935502.html
