最大网络流 EK 算法

          网络流是什么类型的问题，看一道题目你就知道了 点击打开链接 。

默认具备图论的基本知识，网络流概念比较多，先看看书熟悉一下那些概念。比较好！一个寄出的网络最大流。EK算法写的。



 这是一幅网络，求S  ------>  T   点的最大网络流。  这是初始状态。{a,b}  a 代表该边的最大流量，b代表实际的流量。

一开始，实际流量为0；下面是代码。

<pre name="code" class="cpp">#include <cstdio>
#include <cstring>
#include <cctype>
#include <cmath>
#include <set>
#include <map>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <vector>
#include <iostream>
#include <algorithm>
#include <stdlib.h>

using namespace std;
typedef long long LL;
const int INF=2e9+1e8;
const int MOD=1e9+7;
const int MM=250;
const double eps=0.0000000001;

struct Node
{
int c,f;
};
Node edge[MM][MM];
int n,m,pre[MM];

bool bfs(int s,int t)
{
bool vis[MM];
memset(vis,0,sizeof(vis));
memset(pre,-1,sizeof(pre));
queue<int>q;
q.push(s);
vis[s]=true;
while(!q.empty())
{
s=q.front();
q.pop();
for(int i=1; i<=m; i++)
{
if(!vis[i]&&edge[s][i].c>abs(edge[s][i].f))
{
vis[i]=true;
pre[i]=s;
if(i==t) return true;
q.push(i);
}
}
}
return false;
}
void print(stack<int>& a)//打印路径
{
cout<<"1";
while(!a.empty())
{
cout<<"->"<<a.top();
a.pop();
}
cout<<endl;
}
int solve()
{
int maxflow=0;
while(true)
{
if(!bfs(1,m)) return maxflow;
int flow=INF;
stack<int>s;
for(int x=m,y=pre[m]; y!=-1; x=y,y=pre[y])
{
flow=min(flow,edge[y][x].c-edge[y][x].f);
s.push(x);
}
//  print(s);
for(int x=m,y=pre[m]; y!=-1; x=y,y=pre[y])
{
edge[y][x].f+=flow;
edge[x][y].f-=flow;
}
maxflow+=flow;
}
}
int main()
{
while(cin>>n>>m)
{
memset(edge,0,sizeof(edge));
for(int i=0; i<n; i++)
{
int s,t,val;
cin>>s>>t>>val;
edge[s][t].c+=val;
}
printf("%d\n",solve());
}
return 0;
}

/*
_ooOoo_
o8888888o
88" . "88
(| -_- |)
O\  =  /O
____/`---'\____
.'  \\|     |//  `.
/  \\|||  :  |||//  \
/  _||||| -:- |||||-  \
|   | \\\  -  /// |   |
| \_|  ''\---/''  |   |
\  .-\__  `-`  ___/-. /
___`. .'  /--.--\  `. . __
."" '<  `.___\_<|>_/___.'  >'"".
| | :  `- \`.;`\ _ /`;.`/ - ` : | |
\  \ `-.   \_ __\ /__ _/   .-` /  /
======`-.____`-.___\_____/___.-`____.-'======
`=---='
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The program have no BUG.
*/

 

该算法的大致思路是：不断的找寻s到t的可行流。直到找不到为止。每次找到都要之后改变该路径上的实际流量。

用广搜来寻找路径。

比如第一次找到的路径是    S   → 1  →2 →T；增加流量为4

把实际流量更新后得到



再找 S→1→4→T

这条路上S到1只剩下1 所以增加的流量为1 便得到



再找 S→3→4→1

可以增加的流量为 4  ，便得到



下一次将不会找到再可以增加流量的路径。所以程序结束，增加流量为     4+1+4；所以最大流为9；

不过还有一种情况：



从肉眼来看很容易 S→1→2→T     加      S→3→4→T  得到15；

但是计算机执行有可能会首选 S→1→4→T。便得到
 再选择  S→1→2→T得到右图


 
        


就再搜不到其他的了但是得到的确实10；说明这样作并不是最优的。所以EK算法提供了一种后悔的机制。正向流量加的同时，反向容量也同时加。这样就相当于
  让刚刚流经1到4的让他从1→2→T 我从 4→T


  

1与4
这条边，一开始是从1到4流过5，反方的流量就变为5；当另一个流经  S,3,4 时  就可以走1,2，T 。合起来就是

S→3→4→1→2→T
 又增加流量为5 到最后  E<1,4> 这条边总流量为 0；这种机制刚好解决了这个问题。

OVER