ISAP模板

#include<bits/stdc++.h>

using namespace std;

using namespace std;

typedef long long ll;

const int MAXN = 10005;

#define inf 0x3f3f3f3f3f3f3f3f

struct ISAP{

int n;//实际建图总点数（最好比图中总点数大一点）

struct Edge{

	int v,next;

	ll cap,flow;

}edge[MAXN*100];

    int cur[MAXN],pre[MAXN],gap[MAXN],path[MAXN],dep[MAXN];

    int cnt=0;//实际存储总边数

    void init(int n){

        this -> n  =n;

        cnt=0;

        memset(pre,-1,sizeof(pre));

    }

    void AddEdge(int u,int v,ll w,ll rw=0)//加边 单向图三个参数  双向图四个

    {

        edge[cnt] = (Edge){v,pre[u],w,0};

        pre[u]=cnt++;

        edge[cnt] = (Edge){u,pre[v],rw,0};

        pre[v]=cnt++;

    }

    bool bfs(int s,int t){//其实这个bfs可以融合到下面的迭代里，但是好像是时间要长

        memset(dep,-1,sizeof(dep));

        memset(gap,0,sizeof(gap));

        gap[0]=1;

        dep[t]=0;

        queue<int>q;

        while(!q.empty())

        q.pop();

        q.push(t);//从汇点开始反向建层次图

        while(!q.empty()){

            int u=q.front();

            q.pop();

            for(int i=pre[u];i!=-1;i=edge[i].next){

                int v=edge[i].v;

                if(dep[v]==-1&&edge[i^1].cap>edge[i^1].flow)//注意是从汇点反向bfs，但应该判断正向弧的余量

                {

                    dep[v]=dep[u]+1;

                    gap[dep[v]]++;

                    q.push(v);

                    //if(v==s)//感觉这两句优化加了一般没错，但是有的题可能会错，所以还是注释出来，到时候视情况而定

                    //break;

                }

            }

        }

        return dep[s]!=-1;

    }

    ll isap(int s,int t){

        bfs(s,t);

        memcpy(cur,pre,sizeof(pre));

        int u=s;

        path[u]=-1;

        ll ans=0;

        while(dep[s]<n){//迭代寻找增广路

            if(u==t){

                ll f=inf;

                for(int i=path[u];i!=-1;i=path[edge[i^1].v])//修改找到的增广路

                    f=min(f,edge[i].cap-edge[i].flow);

                for(int i=path[u];i!=-1;i=path[edge[i^1].v]){

                    edge[i].flow+=f;

                    edge[i^1].flow-=f;

                }

                ans+=f;

                u=s;

                continue;

            }

            bool flag=false;

            int v;

            for(int i=cur[u];i!=-1;i=edge[i].next){

                v=edge[i].v;

                if(dep[v]+1==dep[u]&&edge[i].cap-edge[i].flow){

                    cur[u]=path[v]=i;//当前弧优化

                    flag=true;

                    break;

                }

            }

            if(flag){

                u=v;

                continue;

            }

            int x=n;

            if(!(--gap[dep[u]]))return ans;//gap优化

            for(int i=pre[u];i!=-1;i=edge[i].next){

                if(edge[i].cap-edge[i].flow&&dep[edge[i].v]<x){

                    x=dep[edge[i].v];

                    cur[u]=i;//常数优化

                }

            }

            dep[u]=x+1;

            gap[dep[u]]++;

            if(u!=s)//当前点没有增广路则后退一个点

            u=edge[path[u]^1].v;

        }

        return ans;

    }

}F;