NOI 2008 志愿者招募

NOI 2008 志愿者招募

考虑用 $ p_i $ 表示第 $ i $ 天实际招收的人数，我们假设我们有三种志愿者，分别是 $ 1\to 2,1 \to 3 , 2\to 3 $ ，我们招手的人数分别是 $ b_1,b_2,b_3 $

那么第一天实际人数就是 $ p_1 = b_1+b_2 \geq a_1 $ ，同理我们把三个不等式写出来：

\[b_1 + b_2 \ge a_1\\b_1 + b_2 + b_3 \ge a_2\\b_2 + b_3 \ge a_3
\]

发现这是个线性规划的模型，而且据说这题玄学线性规划也能跑过去。。

然后考虑把 $ \ge $ 变成 $ = $ ，设 $ d_i $ 是一个大于 $ 0 $ 的整数，并且

\[b_1 + b_2 = a_1 + d_1\\b_1 + b_2 + b_3 = a_2 + d_2\\b_2 + b_3 = a_3 + d_3
\]

然后，我们发现如果第 $ i $ 种志愿者可以在 $ s \to t $ 天工作，那么 $ b_i $ 一定会出现在第 $ s $ 到 $ t $ 个等式种。我们可以考虑利用这个性质，把等式差分一下，于是 $ b_i $ 就必然在 $ s $ 个等式为正， $ t + 1 $ 个等式为负。

网络流有一个经典东西叫流量平衡，即对于一条边 $ x,y $ ，我们这条边的流量在 $ x $ 的流量中作为负值，在 $ y $ 中作为正值。于是可以考虑从 $ s $ 向 $ t + 1 $ 连一条容量无穷，费用为 $ c_i $ 的边。我们发现 $ d_i $ 可以类似做，从 $ i - 1 $ 向 $ i $ 连一条容量无穷，费用 0 的边，表示 $ d_{i-1} $ 。

差分后的式子中还有 $ a_i - a_{i-1} $ 这个东西，如果是正的就从它向汇点连容量为 $ a_i - a_{i-1} $ 的边，否则从原点向它连 $ a_{i-1} - a_i $ 的边，费用为 0 。由于 $ d_i $ 可以随便取，这个最终的网络流费用为的 0 的边必然可以跑满，所以我们就满足了这些限制。最后 $ s \to t + 1 $ 的边就是各个时段的安排的人数。

#include "iostream"
#include "algorithm"
#include "cstring"
#include "cstdio"
#include "queue"
using namespace std;
#define MAXN 1009
#define inf 0x3f3f3f3f
class mincmaxf {
#define maxn 50005
public:
#define N 10006
#define M 100006
#define INF 0x3f3f3f3f
    int tot, lnk[N], cur[N], ter[M], nxt[M], cap[M], cost[M], dis[N], ret;
    bool vis[N];
    void init( ) { tot = 1; }
    int add(int u, int v, int w, int c) {
        ter[++tot] = v, nxt[tot] = lnk[u], lnk[u] = tot, cap[tot] = w, cost[tot] = c;
        return tot;
    }
    int Ade(int u, int v, int w, int c) { add(v, u, 0, -c); return add(u, v, w, c); }
    bool spfa(int s, int t) {
        memset(dis, 0x3f, sizeof(dis));
        memcpy(cur, lnk, sizeof(lnk));
        std::queue<int> q;
        q.push(s), dis[s] = 0, vis[s] = 1;
        while (!q.empty()) {
            int u = q.front();
            q.pop(), vis[u] = 0;
            for (int i = lnk[u]; i; i = nxt[i]) {
                int v = ter[i];
                if (cap[i] && dis[v] > dis[u] + cost[i]) {
                    dis[v] = dis[u] + cost[i];
                    if (!vis[v]) q.push(v), vis[v] = 1;
                }
            }
        }
        return dis[t] != INF;
    }
    int dfs(int u, int t, int flow) {
        if (u == t) return flow;
        vis[u] = 1;
        int ans = 0;
        for (int &i = cur[u]; i && ans < flow; i = nxt[i]) {
            int v = ter[i];
            if (!vis[v] && cap[i] && dis[v] == dis[u] + cost[i]) {
                int x = dfs(v, t, std::min(cap[i], flow - ans));
                if (x) ret += x * cost[i], cap[i] -= x, cap[i ^ 1] += x, ans += x;
            }
        }
        vis[u] = 0;
        return ans;
    }
    int mcmf(int s, int t) {
        int ans = 0;
        while (spfa(s, t)) {
            int x;
            while ((x = dfs(s, t, INF))) ans += x;
        }
        return ret;
    }
} F ;
int n , m;
int s = 1007 , t = 1008;
int A[MAXN];
int main() {
//    freopen("6.in","r",stdin);
    cin >> n >> m;
    F.init(  );
    for( int i = 1 ; i <= n ; ++ i ) scanf("%d",&A[i]);
    for( int i = n + 1 ; i >= 1 ; -- i ) A[i] = A[i] - A[i - 1];
    for( int i = 1 ; i <= n + 1 ; ++ i ) {
        if( A[i] > 0 ) F.Ade( i , t , A[i] , 0 );
        else F.Ade( s , i , -A[i] , 0 );
        if( i != 1 ) F.Ade( i - 1 , i , inf , 0 );
    }
    for( int i = 1 , s , t , c ; i <= m ; ++ i ) {
        scanf("%d%d%d",&s,&t,&c);
        F.Ade( t + 1 , s , inf , c );
    }
    cout << F.mcmf( s , t ) << endl;
}