我的网络流sap，isap，dinic三种方法的对比总结
转载请注明出处：http://blog.csdn.net/sprintfwater/article/details/7913181
Dinic算法
Accepted 1532 15MS 280K 2468 B C++ SpringWater
可能是数据比较水吧，居然和sap算法一个时间效率,这个算法算是最差的了。当然相对与DFS来说还是要强得多
这个算法的基本思想：每次求可达路径都根据刚分好层的图，从src一层层的递增找到des，之后有一次分层，
又深搜。没有gap优化，cur优化，和没有利用insert来避免每次都分层（即当前弧优化）。
总结者：SpringWater(GHQ)
#include<stdio.h>
#include<string.h>
#define mafromn 222
#define MAXN 222
#define MAXE 500000
const int inf = 0x3f3f3f3f;
struct edge
{
int from,to,next;
int c;
}edge[MAXE];
int cnt,head[MAXN],stack[MAXN],dep[MAXN];
void add(int from,int to,int c)
{
edge[cnt].from=from;edge[cnt].to=to;edge[cnt].c=c;
edge[cnt].next=head[from];head[from]=cnt++;
edge[cnt].from=to;edge[cnt].to=from;edge[cnt].c=0;
edge[cnt].next=head[to];head[to]=cnt++;
}
int flow(int n,int src,int des)
{
int tr,res=0;
int i,j,k,f,r,top;
while(1){
memset(dep,-1,n*sizeof(int));
for(f=dep[stack[0]=src]=0,r=1;f!=r;)
{
for(i=stack[f++],j=head[i];j!=-1;j=edge[j].next)
{
if(edge[j].c&&-1==dep[k=edge[j].to]){
dep[k]=dep[i]+1;stack[r++]=k;
if(k==des)
{
f=r;
break;
}
}
}
}
if(dep[des]==-1)break;
for(i=src,top=0;;)
{
if(i==des)
{
for(k=0,tr=inf;k<top;++k)
if(edge[stack[k]].c<tr)tr=edge[stack[f=k]].c;
for(k=0;k<top;++k)
edge[stack[k]].c-=tr,edge[stack[k]^1].c+=tr;
res+=tr;i=edge[stack[top=f]].from;
}
for(j=head[i];j!=-1;j=edge[j].next)
if(edge[j].c&&dep[i]+1==dep[edge[j].to])break;
if(j!=-1)
{
stack[top++]=j;
i=edge[j].to;
}
else
{
if(!top)break;
dep[i]=-1;i=edge[stack[--top]].from;
}
}
}
return res;
}
int main()
{
int i;
int n, m, src, des;
while (~scanf("%d%d", &m, &n))
{
src = 0;//源点为0
des = n - 1;//汇点为n-1
cnt = 0;
memset(head, -1, sizeof(head));
int u, v, c;
for (i =1; i <= m; ++i)
{
scanf("%d%d%d", &u, &v, &c);
--u, --v;
add(u,v,c);
//add(v,u,c); //流量为双向，如果是单向得去掉这句
}
int ans = flow(n, src, des);
printf("%d\n", ans);
}
return 0;
}
SAP和ISAP算法的效率差不多：
总结者：SpringWater(GHQ)
#include <stdio.h>
#include <string.h>
#define MAXN 100010
#define MAXE 400010
const int INF = 0x3f3f3f3f;
struct Edge
{
int to, from, next, cap;
}edge[MAXE];
int head[MAXN],cnt,n,m,src,des;
int dep[MAXN], gap[MAXN]; //dep[des] = 0初始化为0，代表汇点des的深度为0，gap[0] = 1代表深度为0的点有1个，即汇点
void addedge(int cu, int cv, int cw)
{
edge[cnt].from = cu;
edge[cnt].to = cv;
edge[cnt].cap = cw;
edge[cnt].next = head[cu];
head[cu] = cnt++;
edge[cnt].from = cv;
edge[cnt].to = cu;
edge[cnt].cap = 0;
edge[cnt].next = head[cv];
head[cv] = cnt++;
}
int que[MAXN];
void BFS()
{
memset(dep, -1, sizeof(dep));
memset(gap, 0, sizeof(gap));
gap[0] = 1;
int L = 0, R = 0;
dep[des] = 0;
que[R++] = des;
int u, v;
while (L != R) //用光搜的方法，从汇点开始，将此图分层。
{
u = que[L++];
L = L%MAXN;
for (int i=head[u]; i!=-1; i=edge[i].next)
{
v = edge[i].to;
if (edge[i ^1].cap == 0 || dep[v] != -1) //i^1代表i的反向边,edge[i ^1].cap == 0代表v点到u点不可答
continue;
que[R++] = v; //如果v点可达，则加入队列
R = R % MAXN;
++gap[dep[v] = dep[u] + 1]; //v的深度，等于u的深度+1，且深度为dep[v]的点的个数加1
}
}
}
int cur[MAXN],stack[MAXN];
int Sap() //sap模板
{
int res = 0;
BFS();
int top = 0;
memcpy(cur, head, sizeof(head)); //将每个点的第一条边复制给cur，以便于后面找深度u点小1的边不用从头开始找
int u = src, i;
while (dep[src] < n) //如果src找不到一个可达点，则dep[src] = n + 1自动退出
{
if (u == des) //当找到汇点
{
int temp = INF, inser = n;
for (i=0; i!=top; ++i){ //找从src点到des点的所有边中的最容量为temp,而那条边的编号为insert
if (temp > edge[stack[i]].cap){
temp = edge[stack[i]].cap;
inser = i;
}
}
for (i=0; i!=top; ++i) //将正向边-temp，反向变+temp
{
edge[stack[i]].cap -= temp;
edge[stack[i]^1].cap += temp;
}
res += temp; //总的流量加temp
top = inser; //stack只保留从src到最小边insert“前向点”之间的边的信息，即insert边以后的边信息都不要
u = edge[stack[top]].from; //u为insert的”前向点“
}
for (i = cur[u]; i != -1; i = edge[i].next) //当没有断层，找出一个可达边
if (edge[i].cap != 0 && dep[u] == dep[edge[i].to] + 1) break;
if (i != -1) //当找到这个可达边
{
cur[u] = i; //优化下次找dep[u] - 1不用从头开始找了
stack[top++] = i;
u = edge[i].to;
}
else //当没有找到深度为dep[u] - 1的可达边，那只能找深度更大的边
{
/*因为在不断的增广过程中，每个点的dep只会增，不会减，深度比u小1的点已经没有了，
即深度大于等于dep[u]的点过不了，dep[u] - 1这层，而ISAP算法就不能这样优化，因为
它是将所有的点初始化为0，所以大于0的 而这道题把这句话扔掉反而时间还边少了0ms；
不过令人奇怪的是，这题在在去掉这个优化的时候时间反而还从0ms变为了15ms*/
if (--gap[dep[u]] == 0)
break;
int minn = n;
//从头开始找出深度最小的可达边
for (i = head[u]; i != -1; i = edge[i].next)
{
if (edge[i].cap == 0)
continue;
if (minn > dep[edge[i].to])
{
minn = dep[edge[i].to];
cur[u] = i; //优化避免从头找
}
}
++gap[dep[u] = minn + 1];
if (u != src) //如果u不是源点，还得回溯到dep[u] + 1（这里的dep[u]！=minn + 1）层，并将dep[u]层点全部修改变大。一直回溯到源点
u = edge[stack[--top]].from;
}
}
return res;
}
int main()
{
while (~scanf("%d%d", &m, &n))
{
src = 0;//源点为0
des = n - 1;//汇点为n-1
cnt = 0;
memset(head, -1, sizeof(head));
int u, v, c;
for (int i =0; i < m; ++i)
{
scanf("%d%d%d", &u, &v, &c);
--u, --v;//输入是从1点开始，而src是从0点开始
addedge(u,v,c);
// addedge(v,u,c); //流量为双向，如果是单向得去掉这句
}
int ans = Sap();
printf("%d\n", ans);
}
return 0;
}
//题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1532
ISAP算法：
Accepted 1532 0MS 444K 3014 B C++ SpringWater
初步实验这个算法最优：基本思想是将所有点的深度都初始化为0，在增广的过程中就自动分层。
再直接利用SAP算法增广即可，相对与SAP算法相比，只是代码简短一些，其他也占不了什么优势。
总结者：SpringWater(GHQ)
ps：这个代码是我自己敲的。终于敲网络流有种轻车熟路的感觉。
#include<iostream>
#include<stdio.h>
#include<memory.h>
#include<cmath>
using namespace std;
#define MAXN 10005
#define MAXE 200000
#define INF 1e9
int tmp,src,des,cnt;
int n,m;
struct Edge{
int from, to;
int next,cap;
}edge[MAXE];
int head[MAXN];
int gap[MAXN],dep[MAXN],cur[MAXN], stack[MAXN], top;
int ISAP()
{
int cur_fLow,max_fLow,u,insert,i;
memset(dep,0,sizeof(dep));
memset(gap,0,sizeof(gap));
memcpy(cur, head, n);
max_fLow = 0;
u = src;
top = 0;
while(dep[src] < n)
{
if(u == des)
{
cur_fLow = INF;
for(i = 0; i < top; ++i)
{
if(cur_fLow > edge[stack[i]].cap)
{
insert = i;
cur_fLow = edge[stack[i]].cap;
}
}
for(i = 0; i < top; ++i)
{
edge[stack[i]].cap -= cur_fLow;
edge[stack[i]^1].cap += cur_fLow;
}
max_fLow += cur_fLow;
u = edge[ stack[top = insert]].from;
}
for(i = cur[u]; i != -1; i = edge[i].next)
if((edge[i].cap > 0) && (dep[u] == dep[edge[i].to]+1))
break;
if(i != -1)
{
stack[top++] = i;
u = edge[i].to;
}
else
{
if(0 == --gap[dep[u]]) break;
int minn = n;
for(i = head[u]; i != -1; i = edge[i].next)
{
if(edge[i].cap > 0)
minn = (minn > dep[edge[i].to]) ? (cur[u]= i, dep[edge[i].to]) : minn;
}
++gap[dep[u] = minn + 1];
if(u != src) u = edge[stack[--top]].from;
}
}
return max_fLow;
}
void addedge(int u,int v,int f)
{
edge[cnt].next = head[u];
edge[cnt].from = u;
edge[cnt].to = v;
edge[cnt].cap = f;
head[u] = cnt++;
edge[cnt].next = head[v];
edge[cnt].from = v;
edge[cnt].to = u;
edge[cnt].cap = 0;
head[v] = cnt++;
}
int main()
{
while(scanf("%d%d",&m,&n)!=EOF)
{
cnt=0;
src = 0;
des = n-1;
memset(head,-1,sizeof(head));
while(m--)
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
--a, --b;
addedge(a, b, c);
//addedge(b, a, c);如果是无向边的加上这句
}
int ans=ISAP();
printf("%d\n",ans);
}
return 0;
}