[模板]网络流

网络流中的最大流（isap算法）

const int INF=99999999;
struct node
{
    int v,w,f;
    node *next,*back;
}edge[MAXN*4+10];
node *adj[MAXN+10];
node *ecnt=edge;
int S,T;
int d[MAXN*2+10],vis[MAXN*2+10];
inline void addedge(int u,int v,int w)
{
    node *p=++ecnt;
    p->v=v;
    p->w=w;
    p->f=0;
    p->next=adj[u];
    p->back=p+1;
    adj[u]=p;
     
    p=++ecnt;
    p->v=u;
    p->w=0;
    p->f=0;
    p->next=adj[v];
    p->back=p-1;
    adj[v]=p;
}
int aug(int i,int augco)
{
    if(i==T) return augco;
    int mind=T-1,u,augc=0;
    for(node *p=adj[i];p;p=p->next)
    {
        int v=p->v;
        int w=p->w;
        int f=p->f;
        if(w<=f) continue;
        if(d[i]==d[v]+1)
        {
            u=min(augco-augc,w-f);
            u=aug(v,u);
            p->f+=u;
            p->back->f-=u;
            augc+=u;
            if(d[S]>=T) return augc;
            if(augc==augco) break;
        }
        mind=min(mind,d[v]);
    }
    if(augc==0)
    {
        vis[d[i]]--;
        if(!vis[d[i]])
            d[S]=T;
        d[i]=mind+1;
        vis[d[i]]++;
    }
    return augc;
}
int isap()
{
    int ans=0;
    while(d[S]<T)
        ans+=aug(S,INF);
    return ans;
}

网络流中的费用流（lrj的模板，用双端队列优化）

#include<cstdio>
#include<queue>
#include<vector>
#include<cstring>
#include<algorithm>
#include<iostream>
#define MAXN 200
using namespace std;
const int INF=99999999;
struct Edge
{
    int u,v,c,f,cost;
};
struct MCMF
{
    int n,m,s,t;
    vector<Edge>edges;
    vector<int>G[MAXN+10];
    int inq[MAXN+10],d[MAXN+10],p[MAXN+10],a[MAXN+10];
    void init(int n)
    {
        this->n=n;
        for(int i=0;i<n;i++)
            G[i].clear();
        edges.clear();
    }
    void addedge(int from,int to,int cap,int cost)
    {
        edges.push_back((Edge){from,to,cap,0,cost});
        edges.push_back((Edge){to,from,0,0,-cost});
        m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }
    bool bf(int s,int t,int &Flow,int &Cost)
    {
        int i;
        for(i=0;i<=t;i++)
            d[i]=INF;
        memset(inq,0,sizeof(inq));
        d[s]=0; inq[s]=1; p[s]=0; a[s]=INF;
        deque<int>q;
        q.push_front(s);
        while(!q.empty())
        {
            int u=q.front();
            q.pop_front();
            inq[u]=0;
            for(i=0;i<G[u].size();i++)
            {
                int v=edges[G[u][i]].v;
                int c=edges[G[u][i]].c;
                int f=edges[G[u][i]].f;
                int cost=edges[G[u][i]].cost;
                if(c>f&&d[v]>d[u]+cost)
                {
                    d[v]=d[u]+cost;
                    p[v]=G[u][i];
                    a[v]=min(a[u],c-f);
                    if(!inq[v])
                    {
                        inq[v]=true;
                        q.push_back(v);
                    }
                }
            }
        }
        if(d[t]==INF) return false;
        Flow+=a[t];
        Cost+=d[t]*a[t];
        int u=t;
        while(u!=s)
        {
            edges[p[u]].f+=a[t];
            edges[p[u]^1].f-=a[t];
            u=edges[p[u]].u;
        }
        return true;
    }
    int mc(int s,int t)
    {
        int flow=0,cost=0;
        while(bf(s,t,flow,cost));
        return cost;
    }
};