ISAP算法

struct EDGE{
    int v,next,c,f;
}E[maxn<<1];
int head[maxn],tol;
int gap[maxn],dep[maxn],pre[maxn],cur[maxn];

void Init(){
    memset(head,-1,sizeof head);
    tol=0;
}

void add_edge(int u,int v,int f,int rf=0){
    E[tol].v=v;
    E[tol].c=f;
    E[tol].f=0;
    E[tol].next=head[u];
    head[u]=tol++;

    E[tol].v=u;
    E[tol].c=rf;
    E[tol].f=0;
    E[tol].next=head[v];
    head[v]=tol++;
}

int isap(int start,int end,int N){
    memset(gap,0,sizeof gap);
    memset(dep,0,sizeof dep);
    memcpy(cur,head,sizeof head);
    int u=start;
    pre[u]=-1;
    gap[0]=N;
    int ans=0;
    while(dep[start]<N){
        if(u==end){
            int Min=oo;
            for(int i=pre[u];i!=-1;i=pre[E[i^1].v])
                if(Min>E[i].c-E[i].f)
                    Min=E[i].c-E[i].f;
            for(int i=pre[u];i!=-1;i=pre[E[i^1].v]){
                E[i].f+=Min;
                E[i^1].f-=Min;
            }
            u=start;
            ans+=Min;
            continue;
        }
        bool flag=false;
        int v;
        for(int i=cur[u];i!=-1;i=E[i].next){
            v=E[i].v;
            if(E[i].c-E[i].f&&dep[v]+1==dep[u]){
                flag=true;
                cur[u]=pre[v]=i;
                break;
            }
        }
        if(flag){
            u=v;
            continue;
        }
        int Min=N;
        for(int i=head[u];i!=-1;i=E[i].next)
            if(E[i].c-E[i].f&&dep[E[i].v]<Min){
                Min=dep[E[i].v];
                cur[u]=i;