BZOJ1061 NOI2008 志愿者招募 线性规划、费用流

传送门

---

一道思路很妙的线性规划网络流

设\(X_i\)表示第\(i\)天需要的人数，\(P_i\)表示第\(i\)种人雇佣的个数

那么我们可以列出一系列式子

比如说样例就可以列出三个式子：

\(P_1 \geq X_1=2\)

\(P_1 + P_2 \geq X_2 = 3\)

\(P_2 + P_3 \geq X_3=4\)

加入\(N\)个辅助变量\(Y_i\)将式子变为

\(P_1 = 2 + Y_1\)

\(P_1 + P_2 = 3 + Y_2\)

\(P_2+P_3 = 4 + Y_3\)

最后加一个\(0=0\)

然后从第二个式子开始，每一个式子减去上面的一个式子

\(P_1 = 2 + Y_1\)

\(P_2 = 1 + Y_2 - Y_1\)

\(P_3 - P_1 = 1 + Y_3 - Y_2\)

\(-P_2-P_3 = -4 - Y_3\)

稍加变换，把负号项移到另一边

\(P_1=2+Y_1\)

\(P_2 + Y_1 = 1 + Y_2\)

\(P_3 + Y_2 = 1 + Y_3 + P_1\)

\(4 + Y_3 = P_2 + P_3\)

可以发现对于每一个变量，都在这些式子中出现了两次，而且一次在左边，一次在右边（虽然可以将等式两边倒过来但这并不是重点）

我们将每一个式子看作一个点，等式左边看作这一个点的出度，等式右边看作这一个点的入度，也就是需要满足网络流中的流量平衡。而一个变量刚好能够对应网络流中的一条有向边，一个常量又可以看作是从源点或者汇点向其连接的一条有向边。

那么网络流的构图就比较清晰了：

我们对于所有式子建立一个点

式子中的常量对应的是\(X_i-X_{i-1}\)，也就是说如果\(X_i - X_{i-1} > 0\)则从\(S\)向\(i\)连一条流量为\(X_i - X_{i-1}\)，费用为\(0\)的边，反之从这个点连向\(T\)，流量为\(X_{i-1}-X_i\)，费用为\(0\)。

对于式子中的变量则会连在两个式子之间，这个就留给读者自行思考了（明明是不想写）

#include<bits/stdc++.h>
#define int long long
#define INF 0x3f3f3f3f
//This code is written by Itst
using namespace std;

inline int read(){
    int a = 0;
    char c = getchar();
    bool f = 0;
    while(!isdigit(c) && c != EOF){
        if(c == '-')
            f = 1;
        c = getchar();
    }
    if(c == EOF)
        exit(0);
    while(isdigit(c)){
        a = (a << 3) + (a << 1) + (c ^ '0');
        c = getchar();
    }
    return f ? -a : a;
}

const int MAXN = 1007 , MAXM = 100007;
struct Edge{
    int end , upEd , f , c;
}Ed[MAXM];
int head[MAXN] , dis[MAXN] , pre[MAXN] , flo[MAXN];
int N , M , S , T , cntEd = 1;
bool vis[MAXN];
queue < int > q;

inline void addEd(int a , int b , int c , int d = 0){
    Ed[++cntEd].end = b;
    Ed[cntEd].upEd = head[a];
    Ed[cntEd].f = c;
    Ed[cntEd].c = d;
    head[a] = cntEd;
}

inline bool SPFA(){
    memset(dis , 0x3f , sizeof(dis));
    dis[S] = 0;
    while(!q.empty())
        q.pop();
    q.push(S);
    flo[S] = INF;
    while(!q.empty()){
        int t = q.front();
        q.pop();
        vis[t] = 0;
        for(int i = head[t] ; i ; i = Ed[i].upEd)
            if(Ed[i].f && dis[Ed[i].end] > dis[t] + Ed[i].c){
                dis[Ed[i].end] = dis[t] + Ed[i].c;
                flo[Ed[i].end] = min(Ed[i].f , flo[t]);
                pre[Ed[i].end] = i;
                if(!vis[Ed[i].end]){
                    vis[Ed[i].end] = 1;
                    q.push(Ed[i].end);
                }
            }
    }
    return dis[T] != dis[T + 1];
}

int EK(){
    int ans = 0;
    while(SPFA()){
        int cur = T , sum = 0;
        while(cur != S){
            sum += Ed[pre[cur]].c;
            Ed[pre[cur]].f -= flo[T];
            Ed[pre[cur] ^ 1].f += flo[T];
            cur = Ed[pre[cur] ^ 1].end;
        }
        ans += sum * flo[T];
    }
    return ans;
}

signed main(){
#ifndef ONLINE_JUDGE
    freopen("in" , "r" , stdin);
    //freopen("out" , "w" , stdout);
#endif
    N = read();
    M = read();
    T = N + 2;
    int a = 0;
    for(int i = 1 ; i <= N ; ++i){
        int b = read();
        if(b > a){
            addEd(S , i , b - a);
            addEd(i , S , 0);
        }
        else{
            addEd(i , T , a - b);
            addEd(T , i , 0);
        }
        a = b;
    }
    addEd(N + 1 , T , a);
    addEd(T , N + 1 , 0);
    for(int i = 2 ; i <= N + 1 ; ++i){
        addEd(i , i - 1 , INF);
        addEd(i - 1 , i , 0);
    }
    for(int i = 1 ; i <= M ; ++i){
        int l = read() , r = read() , c = read();
        addEd(l , r + 1 , INF , c);
        addEd(r + 1 , l , 0 , -c);
    }
    cout << EK();
    return 0;
}