isap sap 模板

拖拖欠欠终于学了isap。但是最近一直变量名打错是shenmegui，一周打错三次，，三个晚上就没了。

模板抄自yyn- -详细的注释http://blog.csdn.net/u013368721/article/details/30490255，另外isap的大体思路来自这位大牛http://blog.sina.com.cn/s/blog_7c62590b0100qs7z.html

如果之前已经有了dinic的基础，那么学isap真的超快，如果没有也没有关系，看完上面两篇的就会了

大体思路如下

algorithm Improved-Shortest-Augmenting-Path
1 f<-- 0
2 从终点t 开始进行一遍反向 BFS 求得所有顶点的起始距离标号 d(i)
3 i<-- s
4 while d(s) <n do
5 if i =t then // 找到增广路
6 Augment
7 i<-- s // 从源点 s开始下次寻找
8 if Gf 包含从i 出发的一条允许弧 (i,j)
9 then Advance(i)
10 else Retreat(i) //没有从 i 出发的允许弧则回退
11 return f

procedure Advance(i)     //寻找允许弧，避免从头开始找
1 设 (i,j) 为从i 出发的一条允许弧
2 pi(j) <--i //保存一条反向路径，为回退时准备
3 i<-- j // 前进一步，使 j成为当前结点

procedure Retreat(i)    //回退
1 d(i) <-- 1 +min{d(j):(i,j)属于残量网络Gf} //称为重标号的操作
2 if i != s
3 then i<-- pi(i) // 回退一步

procedure Augment     //寻找增广轨
1 pi中记录为当前找到的增广路 P
2 delta<-- min{rij:(i,j)属于P}
3 沿路径P 增广 delta 的流量
4 更新残量网络Gf

关于cur当前弧的优化：避免多次走到重复的位置上，比如走过x->y这条边后，下次再从x为起点开始走是就不再走x->y的边了

关于gap的优化：首先有int num[max_nodes]; // 离 sink 的最短距离等于 i 的节点数量，即  表示里sink距离为i的路还有num[i]条,那么如果num[i] = 0时,表示这样距离的路已经没了,那么比i更长的路上的点显然也到不了sink,所以直接跳出（也就是所谓的断链，不明白的纸上画画就出来了）

#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
#define ls rt << 1
#define rs rt << 1 | 1
#define pi acos(-1.0)
#define eps 1e-8
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int N = 204;

struct node{
	int v, nxt;
	ll w;
}e[N<<1];

int head[N];
int d[N];
int cur[N];
int pre[N];
int num[N];
int st, ed, cnt, nn;
int n, m;

void init()
{
	cnt = 0;
	memset( head, -1, sizeof( head ) );
}

void add( int u, int v, ll w )
{
	e[cnt].v = v;
	e[cnt].w = w;
	e[cnt].nxt = head[u];
	head[u] = cnt++;

	e[cnt].v = u;
	e[cnt].w = 0;
	e[cnt].nxt = head[v];
	head[v] = cnt++;
}

void rev_bfs( )
{
	memset( num, 0, sizeof( num ) );
	memset( d, -1, sizeof( d ) );
	d[ed] = 0;
	num[0] = 1;
	queue <int> q;
	while ( !q.empty() )
		q.pop();
	q.push( ed );
	while( !q.empty() )
	{
		int u = q.front();
		q.pop();
		for( int i = head[u]; ~i; i = e[i].nxt )
		{
			int v = e[i].v;
			if( ~d[v] )
				continue;
			d[v] = d[u]+1;
			q.push(v);
			num[ d[v] ]++;
		}
	}
}

ll isap()
{
	memcpy( cur, head, sizeof head );
	rev_bfs();
	ll flow = 0;
	int u = pre[st] = st, i;

	while( d[ed] < nn )
	{
		if( u == ed )
		{
			int f = inf, tmp;
			for( i = st; i != ed; i = e[ cur[i] ].v )
			{
				if( f > e[ cur[i] ].w )
				{
					f = e[ cur[i] ].w;
					tmp = i;
				}
			}
			for( i = st; i != ed; i = e[ cur[i] ].v )
			{
				e[cur[i]].w -= f;
				e[cur[i]^1].w += f;
			}
			flow += f;
			u = tmp;
		}
		for( i = cur[u]; ~i; i = e[i].nxt )
		{
			int v = e[i].v;
			if( d[v]+1 == d[u] && e[i].w )
				break;
		}
		if( ~i ){
			cur[u] = i;
			pre[ e[i].v ] = u;
			u = e[i].v;
		}
		else
		{
			if( (--num[ d[u] ]) == 0 )
				break;
			int minn = nn;
			for( i = head[u]; ~i; i = e[i].nxt )
			{
				if( e[i].w && minn > d[e[i].v] )
				{
					cur[u] = i;
					minn = d[ e[i].v ];
				}
			}
			d[u] = minn + 1;
			num[ d[u] ]++;
			u = pre[u];
		}
	}
	return flow;
}

int main()
{
	while( ~scanf("%d%d", &n, &m) )
	{
		init();
		int u, v; ll w;
		for( int i = 1; i <= n; ++i )
		{
			scanf("%d%d%lld", &u, &v, &w);
			add( u, v, w );
		}
		st = 1, ed = m, nn = m+1;
		ll ans = isap();
		printf("%lld\n", ans);
	}
	return 0;
}

sap:

#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
#define ls rt << 1
#define rs rt << 1 | 1
#define pi acos(-1.0)
#define eps 1e-8
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int N = 2000;
const int E = 10005;

struct node{
    int nxt, v, cap, w;
}e[E];

int n, m, nn;
int st, ed;
int cnt;
int head[N];
int dep[N];
int cur[N];
int gap[N];
int pre[N];

void init()
{
    cnt = 0;
    memset( head, -1, sizeof( head ) );
    st = 1, ed = n, nn = n + 1;
}

void add( int u, int v, int w, int rw = 0 )
{
    e[cnt].v = v;
    e[cnt].cap = w;
    e[cnt].w = 0;
    e[cnt].nxt = head[u];
    head[u] = cnt++;

    e[cnt].v = u;
    e[cnt].cap = rw;
    e[cnt].w = 0;
    e[cnt].nxt = head[v];
    head[v] = cnt++;
}

int isap()
{
    memset( gap, 0, sizeof( gap ) );
    memset( dep, 0, sizeof( dep ) );
    memcpy( cur, head, sizeof head );
    int u = st;
    pre[u] = -1;
    gap[0] = nn;
    int flow = 0;
    while( dep[st] < nn )
    {
        if( u == ed )
        {
            int minn = inf, tmp;
            for( int i = pre[u]; ~i; i = pre[e[i^1].v] )
            {
                if( minn > e[i].cap - e[i].w )
                {
                    minn = e[i].cap - e[i].w;
                }
            }
            for( int i = pre[u]; ~i; i = pre[e[i^1].v] )
            {
                e[i].w += minn;
                e[i^1].w -= minn;
            }
            u = st;
            flow += minn;
        }
        bool f = 0;
        int v;
        for( int i = cur[u]; ~i; i = e[i].nxt )
        {
            v = e[i].v;
            if( e[i].cap - e[i].w && dep[v]+1 == dep[u] )
            {
                f = 1;
                cur[u] = pre[v] = i;
                break;
            }
        }
        if( f )
        {
            u = v;
            continue;
        }
        int minn = nn;
        for( int i = head[u]; ~i; i = e[i].nxt )
        {
            if( e[i].cap - e[i].w && dep[e[i].v] < minn )
            {
                cur[u] = i;
                minn = dep[e[i].v];
            }
        }
        gap[dep[u]]--;
        if( !gap[dep[u]] )
            return flow;
        dep[u] = minn + 1;
        gap[dep[u]]++;
        if( u != st )
            u = e[pre[u]^1].v;
    }
    return flow;
}

int main()
{
    int tot;
    scanf("%d", &tot);
    for( int ca = 1; ca <= tot; ++ca )
    {
        scanf("%d%d", &n, &m);
        init();
        int u, v, w;
        for( int i = 1; i <= m; ++i )
        {
            scanf("%d%d%d", &u, &v, &w);
            add( u, v, w );
        }
        int ans = isap();
        printf("Case %d: ", ca);
        printf("%d\n", ans);
    }
}

较为稳定的一种isap写法

const int N = 1000;

struct node{
    int v, w, nxt;
}e[N*N];

int head[N];
int pre[N];
int dep[N];
int gap[N];
int cur[N];
int n, m, nn;
int cnt;
int st, ed;
int S[N], top;

void init()
{
    st = cnt = 0;
    memset( head, -1, sizeof( head ) );
}

void add( int u, int v, int w )
{
    e[cnt].v = v;
    e[cnt].w = w;
    e[cnt].nxt = head[u];
    head[u] = cnt++;

    e[cnt].v = u;
    e[cnt].w = 0;
    e[cnt].nxt = head[v];
    head[v] = cnt++;
}

void rev_bfs()
{
	queue <int> q;
	while( !q.empty() )
		q.pop();
	memset( dep, -1, sizeof( dep ) );
	memset( gap, 0, sizeof( gap ) );
	q.push(ed);
	dep[ed] = 0;
	gap[0] = 1;
	while( !q.empty() )
	{
		int u = q.front();
		q.pop();
		for( int i = head[u]; ~i; i = e[i].nxt )
		{
			int v = e[i].v;
			if( ~dep[v] )
				continue;
			q.push(v);
			dep[v] = dep[u] + 1;
			gap[dep[v]]++;
		}
	}
}

int isap()
{
	int flow = 0, u = st, i;
	memcpy( cur, head, sizeof cur );
	rev_bfs();
	top = 0;
	nn = ed + 1;
	while( dep[st] < nn )
	{
		if( u == ed )
		{
			int tmp, minn = inf;
			for( i = 0; i < top; ++i )
			{
				if( minn > e[S[i]].w )
				{
					tmp = i;
					minn = e[S[i]].w;
				}
			}
			for( i = 0; i < top; ++i )
			{
				e[S[i]].w -= minn; 
				e[S[i]^1].w += minn;
			}
			flow += minn;
			top = tmp;
			u = e[S[top]^1].v;
		}
		for( i = cur[u]; ~i; i = e[i].nxt )
		{
			if( e[i].w > 0 && dep[u] == dep[e[i].v] + 1 )
			{
				cur[u] = i;
				break;
			}
		}
		if( ~i )
		{
			S[top++] = cur[u];
			u = e[i].v;
		}
		else
		{
			if( 0 == (gap[dep[u]]) )
				break;
			int minn = nn;
			for( i = head[u]; ~i; i = e[i].nxt )
			{
				if( e[i].w > 0 && minn > dep[e[i].v] )
				{
					minn = dep[e[i].v];
					cur[u] = i;
				}
			}
			dep[u] = minn + 1;
			gap[dep[u]]++;
			if( u != st )
				u = e[S[--top]^1].v;
		}
	}
	return flow;
}