文章标题 网络流模板

//最小费用流 dijkstra
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <set>
#include <map>
#include <algorithm>
#include <math.h>
#include <vector>
using namespace std;
typedef long long ll;

const int inf=0x3f3f3f3f;
const int mod=1e9+7;
const int maxn=1e5+10;
typedef pair<int,int> pii;//first保存最短距离，second保存顶点标号


struct Edge{
    int to,cap,cost,rev;
};

struct MFMC{
    int n;//定点数 
    vector<Edge>G[maxn];//图的表示 
    int dis[maxn];//最短距离 
    int h[maxn];//定点的势 
    int prevv[maxn],preve[maxn];//最短路中的前驱节点和对应的边 

    void init(int n_){//初始化 
        n=n_;
        for (int i=0;i<n_;i++)G[i].clear();
    }

    //想图中增加一条u->v容量为cap,费用为cost 的边 
    void addedge(int u,int v,int cap,int cost){
        G[u].push_back(Edge{v,cap,cost,(int)G[v].size()});
        G[v].push_back(Edge{u,0,-cost,(int)G[u].size()-1});
    }
    //求解s->t容量为flow 的最小费用
    //如果不能增广则返回-1（即s->t没有flow的流量） 
    int min_cost_flow(int s,int t,int flow){
        int res=0;
        for (int i=0;i<n;i++)h[i]=0;
        while (flow>0){
            //dijkstra求最短路 
            priority_queue<pii, vector<pii>, greater<pii> >que;
            for (int i=0;i<n;i++)dis[i]=inf;
            dis[s]=0;
            que.push(make_pair(0,s));
            while (!que.empty()){
                pii p=que.top();que.pop();
                int v=p.second;
                if (dis[v]<p.first)continue;
                for (int i=0;i<G[v].size();i++){
                    Edge &e=G[v][i];
                    if (e.cap>0&&dis[e.to]>dis[v]+h[v]+e.cost-h[e.to]){
                        dis[e.to]=dis[v]+e.cost+h[v]-h[e.to];
                        prevv[e.to]=v;
                        preve[e.to]=i;
                        que.push(make_pair(dis[e.to],e.to));
                    }
                }
            }
            if (dis[t]==inf){
                return -1;
            }
            for (int v=t;v!=s;v=prevv[v])h[v]+=dis[v];
            int d=flow;
            for (int v=t;v!=s;v=prevv[v]){
                d=min(d,G[prevv[v]][preve[v]].cap); 
            } 
            flow-=d;
            res+=d*h[t]; 
            for (int v=t;v!=s;v=prevv[v]){
                Edge &e=G[prevv[v]][preve[v]];
                e.cap-=d;
                G[v][e.rev].cap+=d;
            }
        }
        return res;
    }
}mfmc; 


int main()
{

    return 0;
}

//最小费用流 bellman-Ford 
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <set>
#include <map>
#include <algorithm>
#include <math.h>
#include <vector>
using namespace std;
typedef long long ll;

const int inf=0x3f3f3f3f;
const int mod=1e9+7;
const int maxn=1e5+10;

struct Edge{
    int to,cap,cost,rev;
};

struct MFMC{
    int n;//定点数 
    vector<Edge>G[maxn];//图的表示 
    int dis[maxn];//最短距离 
    int prevv[maxn],preve[maxn];//最短路中的前驱节点和对应的边 

    void init(int n_){//初始化 
        n=n_;
        for (int i=0;i<n_;i++)G[i].clear();
    }

    //想图中增加一条u->v容量为cap,费用为cost 的边 
    void addedge(int u,int v,int cap,int cost){
        G[u].push_back(Edge{v,cap,cost,(int)G[v].size()});
        G[v].push_back(Edge{u,0,-cost,(int)G[u].size()-1});
    }
    //求解s->t容量为flow 的最小费用
    //如果不能增广则返回-1（即s->t没有flow的流量） 
    int min_cost_flow(int s,int t,int flow){
        int res=0;
        while (flow>0){
            //利用belllman-ford求解最短路 
            for (int i=0;i<n;i++) dis[i]=inf;
            dis[s]=0;
            bool update=true;
            while (update){
                update=false;
                for (int v=0;v<n;v++){
                    if (dis[v]==inf)continue;
                    for (int i=0;i<G[v].size();i++){
                        Edge &e=G[v][i];
                        if (e.cap>0&&dis[e.to]>dis[v]+e.cost){
                            dis[e.to]=dis[v]+e.cost;
                            prevv[e.to]=v;
                            preve[e.to]=i;
                            update=true;
                        }
                    }
                }
            }
            if (dis[t]==inf){//不能再增广 
                return -1;
            }
            //沿s->t的最短路尽可能增广 
            int d=flow;
            for (int v=t;v!=s;v=prevv[v]){
                d=min(d,G[prevv[v]][preve[v]].cap);
            }
            flow-=d;
            res+=d*dis[t];
            for (int v=t;v!=s;v=prevv[v]){
                Edge &e=G[prevv[v]][preve[v]];
                e.cap-=d;
                G[v][e.rev].cap+=d;
            }
        }
        return res;
    }
}mfmc; 


int main()
{

    return 0;
}