详解ISAP算法

学习的条件：对网络流有一定的了解，最好是学过网络流的三大算法。

这里以：Drainage Ditches为例

题目大意：给你m条边，n个顶点，每条边有起点，终点，边的容量。
问：最大流是多少。

ISAP算法就是解决最大流的算法（是SAP算法的改进），适用于对时间要求高的题目，不过我一般习惯用Dinic算法了。

【ISAP算法】

      ISAP算法其实与dinic算法相似，dinic算法有两步，第一步建层，确保能否找到汇点，并且深搜时，也必须按照层次来遍历。第二步按照层次查找流。这样你会发现，你每次都需要重新建层，非常浪费时间，其实除了你查找的路上的点的层会变，其他点的层是不变的，所以我们就需要在这里优化一下，不用每一回都重新建层，而是更新他们的层。

第一步和dinic算法一样建层，不过这里是从汇点开始建层，因为这样容易更新他们的层。
第二步，开始查找流，如果找到流，就继续查找（和dinic的查找方法一样），直到找不到，从这里就不一样了，如果找不到，就更新该点的层，然后向后退一步（如果不是源点，就退一步，否则不用），再继续查找，直到出现断层，或者源点的层数高于点的个数。

如果看懂了下面的代码，可以看一下，这个例子，数据较小，可以手画一下，加强理解；

具体的可以看代码：

#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;
#define inf 0x3f3f3f3f
const int maxn=1009;

int pre[maxn],gap[maxn],h[maxn];//pre记录是从哪一条边到达i的，gap记录在i层中有几个点，h记录i点的层次。
int firs[maxn];//邻接表建边
struct node
{
    int  v,flow,nex;
}edge[maxn*maxn];
int N;
void build_edge(int u,int v,int flow)//建边
{
    edge[N]=(node){v,flow,firs[u]};
    firs[u]=N++;
    edge[N]=(node){u,0,firs[v]};
    firs[v]=N++;
}
void bfs(int s,int t)//广搜建层，不过这里是从汇点开始的，别弄错了，
{
    //初始化
    memset(h,-1,sizeof(h));
    memset(gap,0,sizeof(gap));
    queue<int>q;
    while(!q.empty())q.pop();

    q.push(t);
    h[t]=0;//将汇点定义为0层
    gap[0]=1;//0层点的个数加一
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=firs[u];i!=-1;i=edge[i].nex)
        {
            int v=edge[i].v;
            if(h[v]==-1)
            {
                h[v]=h[u]+1;
                gap[h[v]]++;//记录当前层的个数
                q.push(v);
            }
        }
    }
}
int isap(int s,int t,int n)//ISAP算法主体部分
{
    bfs(s,t);
    memset(pre,0,sizeof(pre));//记录该点的前驱是谁（这里的前驱是指边，不是点）
    int ans=0,d,u=s;//ans记录最大流,d记录当前路径中的最小流,u记录当前查找到哪个点了。
    while(h[s]<n)//如果源点的层小于点的个数就可能还有流
    {
        int flag=1;//判断是否能够走，能否找到流。
        if(u==s) d=inf;//如果再次从源点出发，就初始化d，
        for(int i=firs[u];i!=-1;i=edge[i].nex)
        {
            int v=edge[i].v,flow=edge[i].flow;
            if(h[v]+1==h[u]&&flow)
            {
                pre[v]=i;//记录该点是由哪条边到达的
                u=v;//记录要去哪个点
                d=min(d,flow);//记录最小流
                flag=0;//能够往前走
                if(v==t)//如果走到了汇点
                {
                    while(u!=s)//原路返回，更新边的容量，与dinic的dfs思路一样
                    {
                        int j=pre[u];
                        edge[j].flow-=d;
                        edge[j^1].flow+=d;
                        u=edge[j^1].v;
                    }
                    ans+=d;//加上当前找到的流
                }
                break;
            }
        }
        if(flag)//如果没有找到下面的路,就更新点的层次
        {
            if(--gap[h[u]]==0) //如果该层上没有了点，说明没法继续查找了，结束。
                break;
            int min_=n-1;
            for(int i=firs[u];i!=-1;i=edge[i].nex)//查找与u相连的最小层，
            {
                int v=edge[i].v,flow=edge[i].flow;
                if(flow)
                    min_=min(min_,h[v]);
            }
            h[u]=min_+1;//重新给u建层
            gap[h[u]]++;//更新层的个数
            if(u!=s)//重要一步，如果当前点不是源点就要向后退一步，继续查找。
             u=edge[pre[u]^1].v;
        }
    }
    return ans;
}
int main()
{
    int m,n;
    while(~scanf("%d%d",&m,&n))
    {
        memset(firs,-1,sizeof(firs));
        N=0;
        for(int i=0;i<m;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            build_edge(u,v,w);
        }
        printf("%d\n",isap(1,n,n));
    }
    return 0;
}