网络流算法总汇(ek,dinic,isap)
网络流算法之EK
最基础的网络流算法
不停地找增广路进行增广，直到无法增广为止
时间复杂度O(VE^2)
#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
int maxdata=0x7fffffff;
int capacity[200][200],c[1000][1000];//c[i][j]保存初值，因为每次计算都会改变capacity[i][j]的值，capacity[i][j]表示残留网络的容量
int flow[200];//标记从源点到当前点实际还有多少容量可用
int pre[200];//标记在这条路径上当前节点的前驱，同时标记该节点是否在队列中
int x[1000],y[10000],len[10000];//x,y,len存储每条边的信息
int n,m,p; //n 表示边数，m表示节点数，p表示操作数
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[i]=-1表示该点没有入队
pre[src]=0;
flow[src]=maxdata;
myqueue.push(src);
while (!myqueue.empty())
{
int index=myqueue.front();
myqueue.pop();
if (index==des)//index==des说明所有到终点的路已经都搜索完了
break;
for (i=1;i<m+1;i++)
{
if (i!=src&&capacity[index][i]>0&&pre[i]==-1)//i不是源点，且从当前点可以到达i点，i点不在队列中，则i点入队
{
pre[i]=index;//该路径上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)//src表示源点，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,l;
int start,end,ci;
cin>>m>>n;
memset(capacity,0,sizeof(capacity));
memset(flow,0,sizeof(flow));
for (i=1;i<=n;i++)
{
cin>>start>>end>>ci;
x[i]=start; y[i]=end; len[i]=ci;
if (start==end)
continue;
c[start][end]=capacity[start][end]+=ci;
c[end][start]=capacity[end][start]+=ci;
}
scanf("%d",&p);
for (l=1;l<=p;l++)
{
int x1,y1,z1;
for (i=1;i<=m;i++)
for (j=1;j<=m;j++)
capacity[i][j]=c[i][j];
scanf("%d%d%d",&x1,&y1,&z1);
if (x1==0)
printf("%d\n",maxflow(y1,z1));
if (x1==1)//改变编号Y1的边的容量，
{
c[x[y1]][y[y1]]=capacity[x[y1]][y[y1]]=z1;
c[y[y1]][x[y1]]=capacity[y[y1]][x[y1]]=z1;
}
}
}//如果把网络流的图看作一系列的管道，那么求最大流就相当于从源点处注水，求最多最终有多少水可以流到汇点
网络流算法之dinic(适用于二分图,二分图中O(SQRT(V)E)）
O(V^2E)
Dinic算法算是Ek算法的进阶版，在寻找增广路的基础上，增加了分层图的概念。
• 什么是分层图？
• 顾名思义，根据从S到每个点的远近不同，将�图分成若干层。
• Dinic算法即在寻找增广路的基础上，要求增广路上的每个点，属于分层图上不同的层。
多路增广
• 每次不是寻找一条增广路，而是在DFS中，只要可以就递归增广下去，实际上形成了一张增广网。
当前弧优化
• 对于每一个点，都记录上一次检查到哪一条边。因为我们每次增广一定是彻底增广（即这条已经被增广过的边已经发挥出了它全部的潜力，不可能再被增广了），下一次就不必再检查它，而直接看第一个未被检查的边
// Codevs 1993
#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <queue>
using namespace std;
const int max_n = 220;
const int max_m = 220;
const int max_e = max_m * 2;
const int inf = 1e9;
int point[max_n], nxt[max_e], v[max_e], remain[max_e], tot;
int cur[max_n], deep[max_n], n, m;//deep记录分层，cur记录检查到哪一条边（当前弧优化）
inline int getnum() {
char c; int ans = 0;
while ((c = getchar()) == ' ' || c == '\n' || c == '\r');
ans = c - '0';
while (isdigit(c = getchar())) ans = ans * 10 + c - '0';
return ans;
}
inline void addedge(int x, int y, int cap) {
tot++; nxt[tot] = point[x]; point[x] = tot; v[tot] = y; remain[tot] = cap;
tot++; nxt[tot] = point[y]; point[y] = tot; v[tot] = x; remain[tot] = 0;
}
inline bool bfs(int s, int t) //排除容量已经为0的边，进行分层
{
memset(deep, 0x7f, sizeof(deep));
for (int i = 1; i <= n; i++)
cur[i] = point[i];
deep[s] = 0;
queue<int> q;
q.push(s);
while (!q.empty()) {
int now = q.front(); q.pop();
for (int tmp = point[now]; tmp != -1; tmp = nxt[tmp])//注意tmp！=-1，因为从0开始存储
if (deep[v[tmp]] > inf && remain[tmp])
deep[v[tmp]] = deep[now] + 1, q.push(v[tmp]);
}
return deep[t] < inf;
}
int dfs(int now, int t, int limit) //寻找增广路，实际上应该是一个增广网，limit表示当前路径的源点到现在最窄的(剩余流量最小)的边的剩余流量
{
if (!limit || now == t) return limit;
int flow = 0, f;
for (int tmp = cur[now]; tmp != -1; tmp = nxt[tmp]) {
cur[now] = tmp;
if (deep[v[tmp]] == deep[now] + 1 && (f = dfs(v[tmp], t, min(limit, remain[tmp])))) {
flow += f;
limit -= f;
remain[tmp] -= f;
remain[tmp ^ 1] += f;
if (!limit) break;
}
}
return flow;
}
inline int dinic(int s, int t) {
int ans = 0;
while (bfs(s, t))
ans += dfs(s, t, inf);
return ans;
}
int main() {
tot = -1;
memset(point, -1, sizeof(point));
memset(nxt, -1, sizeof(nxt));
m = getnum(); n = getnum();
for (int i = 1; i <= m; i++) {
int x = getnum();
int y = getnum();
int cap = getnum();
addedge(x, y, cap);
}
cout << dinic(1, n) << endl;
}
网络流算法之isap
ISAP（ Improved Shortest Augmenting Path）也是基于分层思想的最大流算法。所不同的是，它省去了Dinic每次增广后需要重新构建分层图的麻烦，而是在每次增广完成后自动更新每个点的『 标号』 （也就是所在的层）
时间复杂度为O(V^2E),和dinic相同，但是实践证明，在一般的网络流图中， ISAP似乎更具时间上的优势。
// Codevs 1993
#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <queue>
using namespace std;
const int max_n = 220;
const int max_m = 220;
const int max_e = max_m * 2;
const int inf = 1e9;
int point[max_n], nxt[max_e], v[max_e], remain[max_e], tot;
int deep[max_n], num[max_n], cur[max_n], lastedge[max_n];//deep记录分层信息，num记录每一层的点数，lastedge记录前驱节点
bool vis[max_n];
int n, m;
inline int getnum() //快速读入
{
char c; int ans = 0;
while ((c = getchar()) == ' ' || c == '\n' || c == '\r');
ans = c - '0';
while (isdigit(c = getchar())) ans = ans * 10 + c - '0';
return ans;
}
inline void addedge(int x, int y, int cap) //处理边的信息，注意从0开始存
{
tot++; nxt[tot] = point[x]; point[x] = tot; v[tot] = y; remain[tot] = cap;
tot++; nxt[tot] = point[y]; point[y] = tot; v[tot] = x; remain[tot] = 0;
}
inline int addflow(int s, int t)
{
int ans = inf, now = t;
while (now != s) {
ans = min(ans, remain[lastedge[now]]);
now = v[lastedge[now] ^ 1];
}
now = t;
while (now != s) {
remain[lastedge[now]] -= ans;
remain[lastedge[now] ^ 1] += ans;
now = v[lastedge[now] ^ 1];//因为isap是从汇点扩展的
}
return ans;
}
inline void bfs(int t) {
for (int i = 1; i <= n; i++)
deep[i] = n;
memset(vis, 0, sizeof(vis));
queue<int> q;
deep[t] = 0;
q.push(t); vis[t] = true;
while (!q.empty()) {
int now = q.front(); q.pop();
for (int tmp = point[now]; tmp != -1; tmp = nxt[tmp])
if (!vis[v[tmp]] && remain[tmp ^ 1]) //remain[tmp^1]求逆向边
{
vis[v[tmp]] = true;
deep[v[tmp]] = deep[now] + 1;
q.push(v[tmp]);
}
}
}
inline int isap(int s, int t) {
int ans = 0, now = s;
bfs(t);
for (int i = 1; i <= n; i++) num[deep[i]]++;
for (int i = 1; i <= n; i++) cur[i] = point[i];//cur 当前弧优化，记录当前检查到哪一条边
while (deep[s] < n) {
if (now == t) {
ans += addflow(s, t);
now = s;
}
bool has_find = false;
for (int tmp = cur[now]; tmp != -1; tmp = nxt[tmp]) {
int u = v[tmp];
if (deep[u] + 1 == deep[now] && remain[tmp]) {
has_find = true;
cur[now] = tmp;
lastedge[u] = tmp;
now = u;
break;
}
}
if (!has_find) {//没有找到增广路，对now当前点重新标号
int minn = n - 1;
for (int tmp = point[now]; tmp != -1; tmp = nxt[tmp])
if (remain[tmp])
minn = min(minn, deep[v[tmp]]); //从所以相连节点中选取编号最小的
if (!(--num[deep[now]])) break;//GAP优化，如果编号出现了断层，说明不能再增广，那么此时的答案即为最大流
num[deep[now] = minn + 1]++;
cur[now] = point[now];
if (now != s)
now = v[lastedge[now] ^ 1];
}
}
return ans;
}
int main() {
tot = -1;
memset(point, -1, sizeof(point));
memset(nxt, -1, sizeof(nxt));
m = getnum(); n = getnum();
for (int i = 1; i <= m; i++) {
int x = getnum();
int y = getnum();
int cap = getnum();
addedge(x, y, cap);
}
cout << isap(1, n) << endl;
}