网络流模板

最大流Emonds_karp：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;

const int INF=0xf777;
const int MAXN=1000;

int n,m,ans;
int vis[MAXN],pre[MAXN];
int mp[MAXN][MAXN];

bool bfs(int s,int t)
{
    memset(vis,0,sizeof(vis));
    memset(pre,0,sizeof(pre));
    vis[s]=1;
    queue<int> Q;
    Q.push(s);
    while(!Q.empty())
    {
        int q=Q.front();Q.pop();
        if(q==t) return true;
        for(int i=1;i<=n;i++)
            if(!vis[i]&&mp[q][i])
            {
                vis[i]=1;
                pre[i]=q;
                Q.push(i);
            }
    }
    return false;
}

int Edmonds_Karp(int s,int t)
{
    int ans=0;
    while(bfs(s,t))
    {
        int minn=INF;
        for(int i=t;i!=s;i=pre[i])
            minn=min(minn,mp[pre[i]][i]);
        for(int i=t;i!=s;i=pre[i])
        {
            mp[pre[i]][i]-=minn;
            mp[i][pre[i]]+=minn;
        }
        ans+=minn;
    }
    return ans;
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        mp[x][y]=z;
    }
    printf("%d",Edmonds_Karp(1,n));
    return 0;
}

最大流dinic：

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

const int INF=0x7f7f7f7f;
const int MAXN=400000;

struct Edge
{
    int to,w,next;
}E[MAXN];
int node=1,head[MAXN],dis[MAXN];
int s,t;
int n,m,ans;

void insert(int u,int v,int w)
{
    E[++node]=(Edge){v,w,head[u]};
    head[u]=node;
    E[++node]=(Edge){u,0,head[v]};
    head[v]=node;
}

bool bfs()
{
    memset(dis,-1,sizeof(dis));
    queue<int> Q;
    Q.push(s);
    dis[s]=0;
    while(!Q.empty())
    {
        int q=Q.front();Q.pop();
        for(int i=head[q];i;i=E[i].next)
            if(E[i].w&&dis[E[i].to]==-1)
            {
                Q.push(E[i].to);
                dis[E[i].to]=dis[q]+1;
            }
    }
    return dis[t]!=-1;
}

int dfs(int x,int flow)
{
    if(x==t) return flow;
    int w,used=0;
    for(int i=head[x];i;i=E[i].next)
        if(E[i].w&&dis[E[i].to]==dis[x]+1)
        {
            w=flow-used;
            w=dfs(E[i].to,min(w,E[i].w));
            E[i].w-=w;
            E[i^1].w+=w;
            used+=w;
            if(used==flow)return flow;
        }
    if(!used) dis[x]=-1;
    return used;
}

void dinic()
{
    while(bfs()) ans+=dfs(s,INF);
}

int main()
{
    scanf("%d%d%d%d",&n,&m,&s,&t);
    for(int i=1;i<=m;i++)
    {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        insert(u,v,w);
    }
    dinic();
    printf("%d",ans);
    return 0;
}

spfa最小费用最大流：

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

const int INF=0x7f7f7f7f;
const int MAXN=100000;

struct Edge
{
    int u,v,w,c,next;//u起点,v终点,w容量,c花费,next下一条边
}E[MAXN];
int node,head[MAXN];
int pre[MAXN],cost[MAXN],vis[MAXN];
int s,t;
int n,m,ans1,ans2;

void insert(int u,int v,int w,int c)
{
    E[++node]=(Edge){u,v,w,c,head[u]};
    head[u]=node;
    E[++node]=(Edge){v,u,0,-c,head[v]};
    head[v]=node;
}

bool spfa()
{
    queue<int> Q;
    memset(cost,0x7f,sizeof(cost));
    Q.push(s);
    cost[s]=0;vis[s]=1;
    while(!Q.empty())
    {
        int q=Q.front();Q.pop();
        for(int i=head[q];i;i=E[i].next)
            if(E[i].w&&cost[q]+E[i].c<cost[E[i].v])
            {
                cost[E[i].v]=cost[q]+E[i].c;
                pre[E[i].v]=i;
                if(!vis[E[i].v])
                {
                    Q.push(E[i].v);
                    vis[E[i].v]=1;
                }
            }
        vis[q]=0;
    }
    return cost[t]!=INF;
}

void mcf()
{
    int minn=INF;
    for(int i=pre[t];i;i=pre[E[i].u])
        minn=min(minn,E[i].w);
    for(int i=pre[t];i;i=pre[E[i].u])
    {
        ans2+=minn*E[i].c;
        E[i].w-=minn;
        E[i^1].w+=minn;
    }
    ans1+=minn;
}

int main()
{
    scanf("%d%d%d%d",&n,&m,&s,&t);
    for(int i=1;i<=m;i++)
    {
        int u,v,w,c;
        scanf("%d%d%d%d",&u,&v,&w,&c);
        insert(u,v,w,c);
    }
    while(spfa()) mcf();
    printf("%d %d",ans1,ans2);//ans1最大流 ans2最小费用
    return 0;
}

zkw最小费用流：

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

const int INF=0x7f7f7f7f;
const int T=601;

struct Edge
{
    int from,to,v,c,next;
}E[1000000];
int node=1;
int head[5000],dis[5000];
bool vis[5000];

int n,m;
int ans;

void ins(int from,int to,int v,int c)
{
    E[++node]=(Edge){from,to,v,c,head[from]};
    head[from]=node;
}
void insert(int from,int to,int v,int c)
{
    ins(from,to,v,c);ins(to,from,0,-c);
}

bool spfa()
{
    memset(vis,0,sizeof(vis));
    memset(dis,0x7f,sizeof(dis));
    queue<int> Q;
    Q.push(T);
    dis[T]=0;vis[T]=1;
    while(!Q.empty())
    {
        int q=Q.front();Q.pop();
        for(int i=head[q];i;i=E[i].next)
            if(E[i^1].v&&dis[q]-E[i].c<dis[E[i].to])
            {
                dis[E[i].to]=dis[q]-E[i].c;
                if(!vis[E[i].to])
                {
                    vis[E[i].to]=1;
                    Q.push(E[i].to);
                }
            }
        vis[q]=0;
    }
    return dis[0]!=INF;
}

int dfs(int x,int f)
{
    if(x==T) return f;
    int w,used=0;
    vis[x]=1;
    for(int i=head[x];i;i=E[i].next)
        if(!vis[E[i].to]&&E[i].v&&dis[E[i].to]==dis[x]-E[i].c)
        {
            w=f-used;
            w=dfs(E[i].to,min(w,E[i].v));
            ans+=w*E[i].c;
            E[i].v-=w;E[i^1].v+=w;
            used+=w;
            if(used==f) return f;
        }
    return used;
}

void zkw()
{
    while(spfa())
    {
        vis[T]=1;
        while(vis[T])
        {
            memset(vis,0,sizeof(vis));
            dfs(0,INF);
        }
    }
}