网络流——最小费用最大流模板

#连续最短路算法#

菜鸡自用的板子。

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<queue>
#include<cmath>
using namespace std;
typedef pair<int, int> _pair;
const int maxv= 510;
const int maxe= 21000;
const int inf= 0x3f3f3f3f;

struct ENode
{
    int to;
    int cap;
    int cost;
    int Next;
};

struct Min_Cost_Max_Flow
{
    ENode edegs[maxe];
    int Head[maxv], tnt;
    int dist[maxv], preV[maxv], preE[maxv];
    void init()
    {
        memset(Head, -1, sizeof(Head));
        tnt= -1;
    }
    void Add_ENode (int _from, int _to, int _cap, int _cost)
    {
        ++ tnt;
        edegs[tnt].to= _to;
        edegs[tnt].cap= _cap;
        edegs[tnt].cost= _cost;
        edegs[tnt].Next= Head[_from];
        Head[_from]= tnt;
        ++ tnt;
        edegs[tnt].to= _from;
        edegs[tnt].cap= 0;
        edegs[tnt].cost= -_cost;
        edegs[tnt].Next= Head[_to];
        Head[_to]= tnt;
    }

    int Min_cost_max_flow (int s, int t, int maxf, int &flow)
    {
        int ret= 0;
        priority_queue<_pair, vector<_pair>, greater<_pair> > q;

        while (maxf)
        {
            memset(dist, inf, sizeof(dist));
            while (! q.empty()) q.pop();
            dist[s]= 0;
            q.push(_pair(0, s));

            while (! q.empty())
            {
                _pair now= q.top();
                q.pop();
                int u= now.second;
                if (dist[u]< now.first) continue;
                for (int k= Head[u]; k!= -1; k= edegs[k].Next)
                {
                    int v= edegs[k].to;
                    if (edegs[k].cap> 0&& dist[v]> dist[u]+ edegs[k].cost)
                    {
                        dist[v]= dist[u]+ edegs[k].cost;
                        preV[v]= u;
                        preE[v]= k;
                        q.push(_pair(dist[v], v));
                    }
                }
            }

            if (dist[t]== inf) break;
            int f= maxf;
            for (int i= t; i!= s; i= preV[i])
            {
                f= min(f, edegs[preE[i]].cap);
            }
            for (int i= t; i!= s; i= preV[i])
            {
                edegs[preE[i]].cap-= f;
                edegs[preE[i]^ 1].cap+= f;
            }
            maxf-= f;
            flow+= f;
            ret+= f* dist[t];
        }
        return ret;
    }
};

Min_Cost_Max_Flow MCMF;
int num[maxv];
int main()
{
    MCMF.init();
    int s= 0, t= n+ 1;
    /*建图*/
    int flow= 0;
    int ans= MCMF.Min_cost_max_flow(s, t, inf, flow);
    printf("%d
", ans);
    return 0;
}

#zkw费用流#

参考网址： https://artofproblemsolving.com/community/c1368h1020435

zkw大佬的改进：①在dfs的时候可以实现多路增广②KM算法节省SPFA时间（然而我这里没有KM，要问为什么，当然是因为我不会了orz）；

but，参考了另外的博客，修修补补又三年~

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#include <cmath>
using namespace std;
const int maxv= 200010;
const int maxe= 2000010;
const int INF= 0x3f3f3f3f;

struct ENode
{
    int to;
    int c;
    int f;
    int Next;
};
ENode edegs[maxe];
int Head[maxv], tnt;
void init()
{
    memset(Head, -1, sizeof(Head));
    tnt= -1;
}
void Add_ENode(int a, int b, int _c, int _f)
{
    ++ tnt;
    edegs[tnt].to= b;
    edegs[tnt].c= _c;
    edegs[tnt].f= _f;
    edegs[tnt].Next= Head[a];
    Head[a]= tnt;
    ++ tnt;
    edegs[tnt].to= a;
    edegs[tnt].c= 0;
    edegs[tnt].f= -_f;
    edegs[tnt].Next= Head[b];
    Head[b]= tnt;
}

bool vis[maxv];  //访问标记
int dist[maxv];  //每个点的距离标号，其实就是dis[];
inline bool spfa(int s, int t)
{
    memset(vis, 0, sizeof(vis));
    memset(dist, INF, sizeof(dist));
    dist[t]= 0;
    vis[t]= 1;//首先SPFA我们维护距离标号的时候要倒着跑，这样可以维护出到终点的最短路径
    deque<int> q;
    q.push_back(t);//使用了SPFA的SLF优化（SLF可以自行百度或Google）

    while(!q.empty())
    {
        int u= q.front();
        q.pop_front();
        for(int k= Head[u]; k!= -1; k=edegs[k].Next)
        {
            int v= edegs[k].to;
            if(edegs[k^1].c&& dist[v]> dist[u]- edegs[k].f)
            {
                /*首先c[k^1]是为什么呢，因为我们要保证正流，但是SPFA是倒着跑的，
                所以说我们要求c[k]的对应反向边是正的，这样保证走的方向是正确的*/
                dist[v]= dist[u]- edegs[k].f;
                /*因为已经是倒着的了，我们也可以很清楚明白地知道建边的时候反向边的边权是负的，
                所以减一下就对了（负负得正）*/
                if(!vis[v])
                {
                    vis[v]= 1;
                    /*SLF优化*/
                    if(! q.empty()&& dist[v]< dist[q.front()])q.push_front(v);
                    else q.push_back(v);
                }
            }
        }
        vis[u]=0;
    }
    return dist[s]< INF;//判断起点终点是否连通
}

int ans; //ans：费用答案
inline int dfs_flow(int now, int c_max, int t)
{
    /*这里就是进行増广了,一次dfs进行了多次增广*/
    if(now== t)
    {
        vis[t]=1;
        return c_max;
    }
    int ret= 0, a;
    vis[now]=1;

    for(int k=Head[now]; k!= -1; k= edegs[k].Next)
    {
        int v= edegs[k].to;
        if(! vis[v]&& edegs[k].c&& dist[v]== dist[now]- edegs[k].f)
        {
            /*这个条件就表示这条边可以进行増广*/
            a= dfs_flow(v, min(edegs[k].c, c_max- ret), t);
            if(a)
            {
                /*累加答案，加流等操作都在这了*/
                ans+= a* edegs[k].f; /*流过时按流量单位计费*/
                //ans+= edegs[k].f; /*流过时费用固定*/
                /**注意上面两句指令的区别*/
                edegs[k].c-= a;
                edegs[k^1].c+= a;
                ret+= a;
            }
            if(ret== c_max)break;
        }
    }
    return ret;
}

inline int Min_Cost_Flow(int s, int t)
{
    int flow= 0;
    ans= 0;  //费用清零
    while(spfa(s, t))
    {
        /*判断起点终点是否连通，不连通说明满流，做完了退出*/
        vis[t]= 1;
        while(vis[t])
        {
            memset(vis, 0, sizeof vis);
            flow+= dfs_flow(s, INF, t);//一直増广直到走不到为止（这样也可以省时间哦）
        }
    }
    return flow;//这里返回的是最大流，费用的答案在ans里
}
int main()
{
    int n, m, s, t;
    scanf("%d %d %d %d", &n, &m, &s, &t);
    init();
    for(int i= 0; i< m; i ++)
    {
        int a, b, c, f;
        scanf("%d%d%d%d", &a, &b, &c, &f);
        Add_ENode(a, b, c, f);
    }
    printf("%d ", Min_Cost_Flow(s, t));
    printf("%d
", ans);
    return 0;
}

 #DAG图上费用流#

大佬标称模板：

《DAG图上的最小(最大)费用最大流，适用负权边》

//author Forsaken
#define Hello the_cruel_world!
#pragma GCC optimize(2)
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<utility>
#include<cmath>
#include<climits>
#include<deque>
#include<functional>
#include<numeric>
#define max(x,y) ((x) > (y) ? (x) : (y))
#define min(x,y) ((x) < (y) ? (x) : (y))
#define lowbit(x) ((x) & (-(x)))
#define FRIN freopen("C:\Users\Administrator.MACHENI-KA32LTP\Desktop\1.in", "r", stdin)
#define FROUT freopen("C:\Users\Administrator.MACHENI-KA32LTP\Desktop\1.out", "w", stdout)
#define FAST ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define outd(x) printf("%d
", x)
#define outld(x) printf("%lld
", x)
#define memset0(arr) memset(arr, 0, sizeof(arr))
#define il inline
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const int maxn = 1e4;
const int INF = 0x7fffffff;
const int mod = 1e9 + 7;
const double eps = 1e-7;
const double Pi = acos(-1.0);
il int read_int()
{
    char c;
    int ret = 0, sgn = 1;
    do
    {
        c = getchar();
    }
    while ((c < '0' || c > '9') && c != '-');
    if (c == '-') sgn = -1;
    else ret = c - '0';
    while ((c = getchar()) >= '0' && c <= '9') ret = ret * 10 + (c - '0');
    return sgn * ret;
}
il ll read_ll()
{
    char c;
    ll ret = 0, sgn = 1;
    do
    {
        c = getchar();
    }
    while ((c < '0' || c > '9') && c != '-');
    if (c == '-') sgn = -1;
    else ret = c - '0';
    while ((c = getchar()) >= '0' && c <= '9') ret = ret * 10 + (c - '0');
    return sgn * ret;
}
il ll quick_pow(ll base, ll index)
{
    ll res = 1;
    while (index)
    {
        if (index & 1)res = res * base % mod;
        base = base * base % mod;
        index >>= 1;
    }
    return res;
}
struct edge
{
    int to, capacity, cost, rev;
    edge() {}
    edge(int to, int _capacity, int _cost, int _rev) :to(to), capacity(_capacity), cost(_cost), rev(_rev) {}
};
struct Min_Cost_Max_Flow
{
    int V, H[maxn + 5], dis[maxn + 5], PreV[maxn + 5], PreE[maxn + 5];
    vector<edge> G[maxn + 5];
    //调用前初始化
    void Init(int n)
    {
        V = n;
        for (int i = 0; i <= V; ++i)G[i].clear();
    }
    //加边
    void Add_Edge(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));
    }
    //flow是自己传进去的变量，就是最后的最大流，返回的是最小费用
    int Min_cost_max_flow(int s, int t, int f, int& flow)
    {
        int res = 0;
        fill(H, H + 1 + V, 0);
        while (f)
        {
            priority_queue <pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>> > q;
            fill(dis, dis + 1 + V, INF);
            dis[s] = 0;
            q.push(pair<int, int>(0, s));
            while (!q.empty())
            {
                pair<int, int> now = q.top();
                q.pop();
                int v = now.second;
                if (dis[v] < now.first)continue;
                for (int i = 0; i < G[v].size(); ++i)
                {
                    edge& e = G[v][i];
                    if (e.capacity > 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];
                        PreV[e.to] = v;
                        PreE[e.to] = i;
                        q.push(pair<int, int>(dis[e.to], e.to));
                    }
                }
            }
            if (dis[t] == INF)break;
            for (int i = 0; i <= V; ++i)H[i] += dis[i];
            int d = f;
            for (int v = t; v != s; v = PreV[v])d = min(d, G[PreV[v]][PreE[v]].capacity);
            f -= d;
            flow += d;
            res += d*H[t];
            for (int v = t; v != s; v = PreV[v])
            {
                edge& e = G[PreV[v]][PreE[v]];
                e.capacity -= d;
                G[v][e.rev].capacity += d;
            }
        }
        return res;
    }
    int Max_cost_max_flow(int s, int t, int f, int& flow)
    {
        int res = 0;
        fill(H, H + 1 + V, 0);
        while (f)
        {
            priority_queue <pair<int, int>> q;
            fill(dis, dis + 1 + V, -INF);
            dis[s] = 0;
            q.push(pair<int, int>(0, s));
            while (!q.empty())
            {
                pair<int, int> now = q.top();
                q.pop();
                int v = now.second;
                if (dis[v] > now.first)continue;
                for (int i = 0; i < G[v].size(); ++i)
                {
                    edge& e = G[v][i];
                    if (e.capacity > 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];
                        PreV[e.to] = v;
                        PreE[e.to] = i;
                        q.push(pair<int, int>(dis[e.to], e.to));
                    }
                }
            }
            if (dis[t] == -INF)break;
            for (int i = 0; i <= V; ++i)H[i] += dis[i];
            int d = f;
            for (int v = t; v != s; v = PreV[v])d = min(d, G[PreV[v]][PreE[v]].capacity);
            f -= d;
            flow += d;
            res += d*H[t];
            for (int v = t; v != s; v = PreV[v])
            {
                edge& e = G[PreV[v]][PreE[v]];
                e.capacity -= d;
                G[v][e.rev].capacity += d;
            }
        }
        return res;
    }
};
int n, k, s1, s2, t, flow, arr[maxn + 5];
Min_Cost_Max_Flow MCMF;
int main()
{
    for (int kase = read_int(); kase > 0; --kase)
    {
        n = read_int(), k = read_int();
        s1 = 0, s2 = 2 * n + 1, t = 2 * n + 2;
        MCMF.Init(t);
        MCMF.Add_Edge(s1, s2, k, 0);
        for (int i = 1; i <= n; ++i)
        {
            arr[i] = read_int();
            MCMF.Add_Edge(i, i + n, 1, arr[i]);
        }
        for (int i = 1; i <= n; ++i)
            for (int j = i + 1; j <= n; ++j)
            {
                if (arr[i] <= arr[j])MCMF.Add_Edge(i + n, j, 1, 0);
            }
        for (int i = 1; i <= n; ++i)
        {
            MCMF.Add_Edge(s2, i, 1, 0);
            MCMF.Add_Edge(i + n, t, 1, 0);
        }
        cout << MCMF.Max_cost_max_flow(s1, t, INF, flow) << endl;
    }
    return 0;
}

end；