BZOJ1061 费用流

题意：有一项工作需要n天完成，第i天需要至少$A_i$个人来工作。
有m种人可以雇佣，第i种人工作$S_i ->Ti$天，雇佣费用$C_i$。
问最少花费多少天完成工作。

本意是想学单纯形做的这个题目，结果学到了费用流的强大建图。

抽取题目中的有用信息可以得到：
$令雇佣第i类志愿者的数目为X_i$。
$Minimum: \sum_{i = 1}^{M} C_i * X_i， X_i \geq 0 | i\in[1, m]$
对于样例1，我们可以建立不等式：

$X_1 \geq 2$
$X_1 + X_2 \geq 3$
$X_2 + X_3 \geq 4$
我们可以对每个不等式加入变量$Y_i$ 使得其转化为等式。
$X_1 + Y_1 = 2$
$X_1 + X_2 + Y_2 = 3$
$X_2 + X_3 + Y_3 = 4$
再添加两个等式使得原方程组变成：
$Y_0 = 0$
$X_1 + Y_1 = 2$
$X_1 + X_2 + Y_2 = 3$
$X_2 + X_3 + Y_3 = 4$
$Y_4 = 0$
对每一项减去前一项，得到方程组
$Y_0 = 0$
$X_1 + Y_1 - Y_0 = 2$
$X_2 - Y_1 + Y_2 = 1$
$X_3 - X_1 + Y_3 - Y_2 = 1$
$Y_4 - Y_3 - X_2 - X_3 = -4$
1. 对于每个方程，可以看做一个节点，如果等式右边的值d大于0，则有$S -> i$，流量为d，费用为0，否则$i -> T$，流量为d，费用为0。
2. 对每个正的$X_i$所在的节点，向负的$X_i$所在的连一条边，流量为INF，费用为$C_i$.
3. 对每个正的$Y_i$所在的节点，向负的$Y_i$所在的连一条边，流量为INF，费用为 0 <script type="math/tex" id="MathJax-Element-90">0</script>.
跑一次最小费用最大流即可。

至于为什么是对的？我是这么理解的：
对左边的若干个相互关联的变量以某种恰当的方式将其赋值，使所有等式满足要求，这不就是对应着网络流的流量平衡吗？
虽然跑的挺慢就是了= =…跑30MS的都是单纯性吗？

#include <bits/stdc++.h>

using namespace std;

int n, m;
int v[1111];
typedef long long LL;
struct MCMF {

    static const LL INF = 1e18;
    static const LL maxn = 1111;
    static const LL maxm = 220000;

    struct Edge {
        LL u, v, next, flow, cap, cost;
    } edge[maxm*2];

    LL head[maxn], eg;
    LL dis[maxn], vis[maxn], p[maxn], a[maxn];

    void AddEdge(LL u, LL v, LL cap, LL cost) {
        edge[eg] = {u, v, head[u], 0, cap, cost}, head[u] = eg++;
        swap(u, v);
        edge[eg] = {u, v, head[u], 0, 0, -cost}, head[u] = eg++;
    }

    void init() {
        eg = 0;
        memset(head, -1, sizeof head);
    }

    bool SPFA(LL s, LL t, LL n, LL& flow, LL &cost) {
        for(LL i = 0; i < n; i++) dis[i] = INF, vis[i] = 0;
        dis[s] = 0, vis[s] = 1, p[s] = 0, a[s] = INF;
        queue<LL> Q;
        Q.push(s);
        while(!Q.empty()) {
            LL u = Q.front(); Q.pop();
            vis[u] = 0;
            for(LL i = head[u]; ~i; i = edge[i].next) {
                Edge& e = edge[i];
                if(e.flow < e.cap && dis[e.v] > dis[u] + e.cost) {
                    dis[e.v] = dis[u] + e.cost;
                    p[e.v] = i;
                    a[e.v] = min(a[u], e.cap - e.flow);
                    if(!vis[e.v]) vis[e.v] = 1, Q.push(e.v);
                }
            }
        }
        if(dis[t] == INF) return 0;
        flow += a[t];
        cost += a[t] * dis[t];
        int u = t;
        while(s != u) {
            edge[p[u]].flow += a[t];
            edge[p[u]^1].flow -= a[t];
            u = edge[p[u]].u;
        }
        return 1;
    }
    void operator()(LL s, LL t, LL n, LL& flow, LL& cost) {
        flow = cost = 0;
        while(SPFA(s, t, n, flow, cost)) ;
    }
} mcmf;

int main() {
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++)
        scanf("%d", &v[i]);
    mcmf.init();
    for(int i = 1; i <= m; i++) {
        int u, v, c;
        scanf("%d%d%d", &u, &v, &c);
        mcmf.AddEdge(u, v + 1, 1e18, c);
    }
    int s = n + 2;
    int t = n + 3;
    for(int i = 1; i <= n + 1; i++) {
        int d = v[i] - v[i-1];
        if(d > 0)
            mcmf.AddEdge(s, i, d, 0);
        else
            mcmf.AddEdge(i, t, -d, 0);
        mcmf.AddEdge(i, i - 1, 1e18, 0);
    }
    LL cost, flow;
    mcmf(s,t,n+4, flow, cost);
    printf("%lld\n", cost);
    return 0;
}