网络流入门6—（最大流算法ISAP）

文章参考：http://blog.csdn.net/u014800748/article/details/44045073

http://blog.csdn.net/u013368721/article/details/30490255

ISAP算法

ISAP（Improved Shortest Augumenting Path）算法是改进版的SAP算法，如果对效率要求很高的时候，可以用该算法。

（1）概述：算法基于这样的一个事实：每次增广之后，任意结点到汇点（在残余网络中）的最短距离都不会减小。这样，我们可以利用d[i[表示结点i到汇点的距离的下界。然后再增广过程当中不断地修改这个下界。增广的时候和Dinic算法类似，只允许沿着d[i]==d[j]+1的弧(i,j)走。

概括地说，ISAP 算法就是不停地找最短增广路，找到之后增广；如果遇到死路就 retreat，直到发现 s s,  t t不连通，算法结束。找最短路本质上就是无权最短路径问题，因此采用 BFS 的思想。具体来说，使用一个数组 d d，记录每个节点到汇点 t t的最短距离。搜索的时候，只沿着满足 d[u]=d[v]+1                            d[u]=d[v]+1的边 u→v   u→v（这样的边称为允许弧）走。显然，这样走出来的一定是最短路。

不难证明，d[i]满足两个条件：(1)d[t]=0;(2)对任意的弧(i,j) d[i]≤d[j]+1。因为最坏的情况就是s到t是一条链，此时等号成立。因此，当d[s]≥n时，残余网络中不存在s-t路。

那么与Dinic算法类似，事先逆向bfs，找增广的过程就是沿着“允许弧”（即满足f<c且d[i]==d[j]+1的弧）往前走。（称为“前进”）。如果向前走不动了，那么就要考虑原路返回（称为“撤退”）。此时把d[i]修改为min{d[j]}+1即可。因为要满足d函数的条件(2)。修改后，原来的i值的个数就减少一个，而新i值的个数多一个。在程序中，用num数组来保存所有距离的个数，当把距离值从x修改为y时，num[x]--,num[y]++即可，然后检查num[x]是否为0，如果是0，那么s-t不连通，算法终止。原因显而易见：比如s-t的距离是3，如果距离为2的情况都已经没了，更别提走到距离为1的点了。这就是所谓的“gap优化”。

通过之前的分析，在数据结构方面，该算法只比Dinic算法的数据结构多了两个数组：用于记录父边以便于撤退的数组p，以及标记距离个数的数组num。增广的时候分为两步，第一步逆推求出可改进量a（即残余量的最小值）；第二步再逆推一遍，进行增广。主过程中，x走到汇点时增广。

如果还不懂可参考：http://www.renfei.org/blog/isap.html

isap模板题：

结合poj1273具体代码如下：

#include <stdio.h>    
#include <string.h>    
#include <algorithm>    
#define clear(A, X) memset (A, X, sizeof A)    
#define copy(A, B) memcpy (A, B, sizeof A)    
using namespace std;    
    
const int maxE = 1000000;    
const int maxN = 100000;    
const int maxQ = 1000000;    
const int oo = 0x3f3f3f3f;    
     
struct Edge {    
   int v;//弧尾    
   int c;//容量    
   int n;//指向下一条从同一个弧头出发的弧    
} edge[maxE];//边组    
    
   
int adj[maxN], cntE;//前向星的表头    
int Q[maxQ], head, tail;//队列    
int d[maxN], cur[maxN], pre[maxN], num[maxN];    
int sourse, sink, nv;//sourse：源点，sink：汇点，nv：编号修改的上限    
int n, m;    
    
void addedge (int u, int v, int c) {//添加边    
    //正向边    
    edge[cntE].v = v;    
    edge[cntE].c = c;//正向弧的容量为c    
    edge[cntE].n = adj[u];    
    adj[u] = cntE++;    
        
    //反向边    
    edge[cntE].v = u;    
    edge[cntE].c = 0;//反向弧的容量为0    
    edge[cntE].n = adj[v];    
    adj[v] = cntE++;    
}    
     
void rev_bfs () {//反向BFS标号    
    clear (num, 0);    
    clear (d, -1);//没标过号则为-1    
    d[sink] = 0;//汇点默认为标过号    
    num[0] = 1;    
    head = tail = 0;    
    Q[tail++] = sink;    
     
    while (head != tail) {    
        int u = Q[head++];    
        for (int i = adj[u]; ~i; i = edge[i].n) {    
            int v = edge[i].v;    
            if (~d[v]) continue;//已经标过号    
            d[v] = d[u] + 1;//标号    
            Q[tail++] = v;    
            num[d[v]]++;    
        }    
    }    
}    
    
int ISAP() {    
    copy (cur, adj);//复制，当前弧优化    
    rev_bfs ();//只用标号一次就够了，重标号在ISAP主函数中进行就行了    
    int flow = 0, u = pre[sourse] = sourse, i;    
    
    while (d[sink] < nv) {//最长也就是一条链，其中最大的标号只会是nv - 1，如果大于等于nv了说明中间已经断层了。    
        if (u == sink) {//如果已经找到了一条增广路，则沿着增广路修改流量    
            int f = oo, neck;    
            for (i = sourse; i != sink; i = edge[cur[i]].v) {    
                if (f > edge[cur[i]].c){    
                    f = edge[cur[i]].c;//不断更新需要减少的流量    
                    neck = i;//记录回退点，目的是为了不用再回到起点重新找    
                }    
            }    
            for (i = sourse; i != sink; i = edge[cur[i]].v) {//修改流量    
                edge[cur[i]].c -= f;    
                edge[cur[i] ^ 1].c += f;    
            }    
            flow += f;//更新    
            u = neck;//回退    
        }    
        for (i = cur[u]; ~i; i = edge[i].n) if (d[edge[i].v] + 1 == d[u] && edge[i].c) break;    
        if (~i) {//如果存在可行增广路，更新    
            cur[u] = i;//修改当前弧    
            pre[edge[i].v] = u;    
            u = edge[i].v;    
        }    
        else {//否则回退，重新找增广路    
            if (0 == (--num[d[u]])) break;//GAP间隙优化，如果出现断层，可以知道一定不会再有增广路了    
            int mind = nv;    
            for (i = adj[u]; ~i; i = edge[i].n) {    
                if (edge[i].c && mind > d[edge[i].v]) {//寻找可以增广的最小标号    
                    cur[u] = i;//修改当前弧    
                    mind = d[edge[i].v];    
                }    
            }    
            d[u] = mind + 1;    
            num[d[u]]++;    
            u = pre[u];//回退    
        }    
    }    
        
    return flow;    
}    
    
void init () {//初始化    
    clear (adj, -1);    
    cntE = 0;    
}    
    
void work () {    
    int u, v, c;    
    init ();    
    for (int i = 0; i < m; ++ i) scanf ("%d%d%d", &u, &v, &c), addedge (u, v, c);    
    sourse = 1; sink = n; nv = sink + 1;    
    printf ("%d\n", ISAP ());    
}      
int main() {    
    while (~scanf("%d%d", &m, &n)) work ();    
    return 0;    
}