最大流 isap算法 模板

ISAP（ImprovedShortestAugmentingPath）也是基于分层思想的最大流算法。所不同的是，它省去了Dinic每次增广后需要重新构建分层图的麻烦，而是在每次增广完成后自动更新每个点的标号（也就是所在的层）

算法流程

1. 利用BFS从开始反向标号（分层）。
2. 进行递归，若当前节点 i
   (1)为汇点，则进行增广，同时退回到起点准备进行新一轮增广路的寻找。
   (2)在残量网络中存在一条边 (i,j) ， c′ij>0 ,且 deepi=deepj+1 （即满足分层图的要求），则前进到 j 点。
3. 没有满足条件的出边，对 i 点重新进行标号。 deepi=min{deepj|(i,j)∈E′,c′ij>0} ，其中 E′ 为残量网络的边集。

算法结束的条件： deeps=+∞ （类似于Dinic，即在残量网络中已不存在s到t的通路。

时间复杂度

渐进时间复杂度和dinic相同，但是非二分图的情况下isap更具优势。

优化

1、当前弧优化：和dinic相同
2、GAP优化：
numk 记录当前有多少点编号为 k
若 ∃k∈[0,deeps],numk=0 ,则说明当前的网络不可能再被增广，可以直接退出。

代码

// codevs 1993
#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
using namespace std;

const int max_n=205;
const int max_m=205;
const int max_e=max_m*2;
const int inf=1e9;

int point[max_n],next[max_e],v[max_e],remain[max_e],tot;
int cur[max_n],deep[max_n],last[max_n],num[max_n];
int n,m,x,y,cap,maxflow;
queue <int> q;

inline void add(int x,int y,int cap){
    ++tot; next[tot]=point[x]; point[x]=tot; v[tot]=y; remain[tot]=cap;
    ++tot; next[tot]=point[y]; point[y]=tot; v[tot]=x; remain[tot]=0;
}

inline void bfs(int t){
    for (int i=1;i<=n;++i)
      deep[i]=n;
    deep[t]=0;
    while (!q.empty()) q.pop();
    q.push(t);

    while (!q.empty()){
        int now=q.front(); q.pop();
        for (int i=point[now];i!=-1;i=next[i])
          if (deep[v[i]]==n&&remain[i^1]){
            deep[v[i]]=deep[now]+1;
            q.push(v[i]);
          }
    }
}

inline int addflow(int s, int t) {
    int ans=inf,now=t;
    while (now!=s) {
        ans=min(ans, remain[last[now]]);
        now=v[last[now] ^ 1];
    }
    now=t;
    while (now != s) {
        remain[last[now]]-=ans;
        remain[last[now]^1]+=ans;
        now=v[last[now]^1];
    }
    return ans;
}

inline void isap(int s,int t){
    int 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];

    //在残量网络中没有源点到汇点的通路 
    while (deep[s]<n){
        //如果到达汇点则进行增广，重新回到源点准备下一轮增广 
        if (now==t){
            maxflow+=addflow(s,t);
            now=s;
        }

        bool has_find=false;
        //当前弧优化 
        for (int i=cur[now];i!=-1;i=next[i]){
            int u=v[i];
            if (deep[u]+1==deep[now]&&remain[i]){
                has_find=true;
                cur[now]=i;
                last[u]=i;
                now=u;
                break;
            }
        }

        //没有找到出边，重新进行标号 
        if (!has_find){
            int minn=n-1;
            for (int i=point[now];i!=-1;i=next[i])
              if (remain[i])
                minn=min(minn,deep[v[i]]);
            //GAP优化 
            if (!(--num[deep[now]])) break;
            num[deep[now]=minn+1]++;
            cur[now]=point[now];
            if (now!=s)
              now=v[last[now]^1];
        }
    }
}

int main(){
    tot=-1;
    memset(point,-1,sizeof(point));
    memset(next,-1,sizeof(next));

    scanf("%d%d",&m,&n);
    for (int i=1;i<=m;++i){
        scanf("%d%d%d",&x,&y,&cap);
        add(x,y,cap);
    }

    isap(1,n);
    printf("%d\n",maxflow);
}