最小费用流模板

O(FVE)

应用bellman_ford算法求最短路

#include<cstring>
#include<vector>

using namespace std;

struct edge
{
    int to, cap, cost, rev;
    edge(int a, int b, int c, int d)
    :to(a), cap(b), cost(c), rev(d){}
};

const int maxn = 10e5;
const int inf  = 0x3f3f3f3f;

int n, m, f;
vector<edge> G[maxn];
int dis [maxn];
int pv[maxn], pe[maxn];

void add(int from, int to, int cap, int cost)
{
    G[from].push_back(edge(to, cap, cost, G[to].size()));
    G[to].push_back(edge(from, 0, -cost, G[from].size() - 1));
}

void bellman_ford(int s)
{
    memset(dis, inf, sizeof dis);
        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;
                        pv[e.to] = v;
                        pe[e.to] = i;
                        update = true;
                    }
                }
            }
        }
}

int min_cost_flow(int s, int t, int f)
{
    int res = 0;
    while(f > 0)
    {
        bellman_ford(s);

        if(dis[t] == inf) return -1;

        int d = f;
        for(int v = t; v != s; v = pv[v])
            d = min(d, G[pv[v]][pe[v]].cap);

        f -= d;
        res += d * dis[t];

        for(int v= t; v != s; v = pv[v])
        {
            edge &e = G[pv[v]][pe[v]];
            e.cap -= d;
            G[v][e.rev].cap += d;
        }
    }

    return res;
}

O(FVV)

导入“势”的概念通过dijkstra求解

#include<vector>
#include<queue>
#include<cstring>

using namespace std;

typedef pair<int, int> P;
struct edge
{
    int to, cap, cost, rev;
    edge(int a, int b, int c, int d)
    :to(a), cap(b), cost(c), rev(d){}
};

const int maxn = 1e5;
const int  inf = 0x3f3f3f3f;

int n, m, f;
vector<edge> G[maxn];
int h[maxn];
int dis[maxn];
int pv[maxn], pe[maxn];

void add(int from, int to, int cap, int cost)
{
    G[from].push_back(edge(to, cap, cost, G[to].size()));
    G[to].push_back(edge(from, 0, -cost, G[from].size() - 1));
}

void dijkstra(int s)
{
    priority_queue<P, vector<P>, greater<P> > qu;
    memset(dis, inf, sizeof dis);
    dis[s] = 0;
    qu.push(P(0, s));

    while(qu.size())
    {
        P p = qu.top();qu.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] + e.cost + h[v] - h[e.to])
            {
                dis[e.to] = dis[v] + e.cost + h[v] - h[e.to];
                pv[e.to] = v;
                pe[e.to] = i;
                qu.push(P(dis[e.to], e.to));
            }
        }
    }
}

int min_cost_flow(int s, int t, int f)
{
    int res = 0;
    memset(h, 0, sizeof h);

    while(f > 0)
    {
        dijkstra(s);

        if(dis[t] == inf) return -1;

        for(int v= 0; v< n; v++)
            h[v] += dis[v];

        int d = f;
        for(int v= t; v!= s; v= pv[v])
            d = min(d, G[pv[v]][pe[v]].cap);

        f -= d;
        res += d * h[t];

        for(int v= t; v!= s; v= pv[v])
        {
            edge &e = G[pv[v]][pe[v]];
            e.cap -= d;
            G[e.to][e.rev].cap += d;
        }
    }

    return res;
}

注意

如果原图中存在负边，h[] 的初值需要用 bellman_ford算法求解