最大流 Dinic + Sap 模板

不说别的，直接上模板。

Dinic+当前弧优化：

struct Edge{
    int x,y,c,ne;
}e[M*];
int be[N],all;
int d[N],q[N];
int stack[N],top;//栈存的是边
int cur[N];//当前弧优化
void add(int x, int y, int z)//需保证相反边第一个为偶数
{
    e[all].x=x; e[all].y=y; e[all].c=z;
    e[all].ne=be[x];
    be[x]=all++;
    e[all].x=y; e[all].y=x; e[all].c=;
    e[all].ne=be[y];
    be[y]=all++;
}
bool BFS(int s, int t)//化为层次图 使得边数从m降低为n 复杂度随之下降
{
    memset(d,-,sizeof(d));
    int head=,tail=;
    q[++tail]=s;
    d[s]=;
    while(head!=tail)
    {
        int u=q[++head];
        for(int i=be[u]; i!=-; i=e[i].ne)
        if(e[i].c> && d[e[i].y]==-){
            d[e[i].y]=d[u]+;
            q[++tail]=e[i].y;
            if(tail==N-) tail=;
            if(e[i].y==t) return ;
        }
    }
    return ;
}

int Dinic(int s, int t)//防止爆栈 用stack模拟递归
{
    int ans=;
    while(BFS(s,t))
    {
        memcpy(cur,be,sizeof(be));
        int u=s;
        top=;//dfs开始 清空栈
        while()
        {
            if(u==t)
            {
                int minc=,mini;
                for(int i=; i<top; i++)
                    if(minc>e[stack[i]].c)
                    {
                        minc=e[stack[i]].c;
                        mini=i;//以便之后回到这继续增广
                    }
                for(int i=; i<top; i++)
                {
                    e[stack[i]].c-=minc;
                    e[stack[i]^].c+=minc;//第一个二进制取反 即取相反边
                }
                ans+=minc;
                top=mini;
                u=e[stack[mini]].x;
            }
            for(int i=cur[u]; i!=-; cur[u]=i=e[cur[u]].ne)
                if(e[i].c> && d[e[i].y]==d[e[i].x]+) break;
            if(cur[u]!=-)
            {
                stack[top++]=cur[u];
                u=e[cur[u]].y;
            }else
            {
                if(top==) break;   //循环结束标志
                d[u]=-;//当前节点不在增广路中 删除
                u=e[stack[--top]].x;//回溯
            }
        }
    }
    return ans;
}

ISAP+GAP+当前弧优化：

struct Edge{
    int x,y,c,ne;
}e[M*];
int x,y,z,n,m,s,t;
int be[N],all;
int d[N],q[N];
int stack[N];//模拟递归
int gap[N],cur[N];//gap优化+当前弧优化

void add(int x, int y, int z)//保证第一个为偶数
{
    e[all].x=x; e[all].y=y; e[all].c=z;
    e[all].ne=be[x];
    be[x]=all++;
    e[all].x=y; e[all].y=x; e[all].c=;
    e[all].ne=be[y];
    be[y]=all++;
}

void BFS(int s, int t)
{
    memset(d,-,sizeof(d));
    memset(gap,,sizeof(gap));
    gap[]=;
    int head=,tail=;
    q[++tail]=t;
    d[t]=;
    while(head!=tail)
    {
        int u=q[++head];
        for(int i=be[u]; i!=-; i=e[i].ne)
            if(d[e[i].y]==-)
            {
                d[e[i].y]=d[u]+;
                q[++tail]=e[i].y;
                gap[d[e[i].y]]++;
            }
    }
}

int sap(int s, int t, int n)
{
    int ans=;
    BFS(s,t);
    memcpy(cur,be,sizeof(be));
    int top=;
    int u=s;
    while(d[s]<n)
    {
        if(u==t)
        {
            int minc=,mini;
            for(int i=; i<top; i++)
                if(minc>e[stack[i]].c)
                {
                    minc=e[stack[i]].c;
                    mini=i;
                }
            for(int i=; i<top; i++)
            {
                e[stack[i]].c-=minc;
                e[stack[i]^].c+=minc;
            }
            ans+=minc;
            top=mini;
            u=e[stack[mini]].x;
            continue;
        }
        for(int i=cur[u]; i!=-; cur[u]=i=e[i].ne)//当前弧优化
            if(e[i].c> && d[e[i].y]+==d[u]) break;
        if(cur[u]!=-)
        {
            stack[top++]=cur[u];
            u=e[cur[u]].y;
        }else
        {
            int mind=n;
            for(int i=be[u]; i!=-; i=e[i].ne)//更新距离标号
                if(e[i].c> && mind>d[e[i].y])
                {
                    mind=d[e[i].y];
                    cur[u]=i;
                }
            gap[d[u]]--;
            if(!gap[d[u]]) return ans;//gap表示当前距离的点有多少个 一旦==0 说明断层直接退出循环
            d[u]=mind+;
            gap[d[u]]++;
            if(u!=s) u=e[stack[--top]].x;
        }
    }
    return ans;
}

void init()
{
    all=;
    memset(be,-,sizeof(be));
}