loj 6008 餐巾计划

题目传送门

　　传送门

题目大意

　　（经典题还不知道题意？）

　　容易想到需要把未使用的餐巾和已经使用的餐巾分开。

　　设$X_i$表示第$i$天已经的使用餐巾的点，设$Y_i$表示第$i$天还未使用的餐巾的点

　　我们知道使用过的餐巾数量 = 洗出来的餐巾数量 + 购买的餐巾数量（一个餐巾被多次洗出来算多次）。

　　右边是啥，我们不清楚，但是我们清楚每一天新增的使用过的餐巾的数量，所以源点向$X_i$连一条容量为$r_i$，费用为0的边。

　　接下来还有几种连边：

• $X_i$向$X_{i + 1}$连一条容量为$infty$，费用为0的边（使用过的餐巾还是使用过的，$i < n$）。
• $Y_i$向$Y_{i + 1}$连一条容量为$infty$，费用为0的边
• $X_i$向$Y_{i + M}$连一条容量为$infty$，费用为$F$的边
• $X_i$向$Y_{i + N}$连一条容量为$infty$，费用为$S$的边

　　对于第$i$天会用掉$r_i$的餐巾，所以$Y_i$向汇点连一条容量为$r_i$，费用为0的边。

　　还有一个购买餐巾，它直接会变成这一天的未使用过的餐巾，所以原点向$Y_i$连一条容量为$infty$，费用为$p$的边。

Code

/**
 * loj
 * Problem#6008
 * Accepted
 * Time: 701ms
 * Memory: 636k
 */
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <queue>
using namespace std;
typedef bool boolean;

template <typename T>
void pfill(T* pst, const T* ped, T val) {
    for ( ; pst != ped; *(pst++) = val);
}

typedef class Edge {
    public:
        int ed, nx, r, c;

        Edge(int ed = 0, int nx = 0, int r = 0, int c = 0) : ed(ed), nx(nx), r(r), c(c) {    } 
} Edge;

typedef class MapManager {
    public:
        int* h;
        vector<Edge> es;

        MapManager() {    }
        MapManager(int n) {
            h = new int[(n + 1)];
            pfill(h, h + n + 1, -1);
        }

        void addEdge(int u, int v, int r, int c) {
            es.push_back(Edge(v, h[u], r, c));
            h[u] = (signed) es.size() - 1;
        }

        void addArc(int u, int v, int cap, int c) {
            addEdge(u, v, cap, c);
            addEdge(v, u, 0, -c);
        }

        Edge& operator [] (int p) {
            return es[p];
        }
} MapManager;

const signed int inf = (signed) (~0u >> 1);

class Graph {
    public:
        int S, T;
        MapManager g;
        
        int *le;
        int *f, *mf;
        boolean *vis;

        // be sure T is the last node
        void set(int S, int T) {
            this->S = S;
            this->T = T;
            f = new int[(T + 1)];
            le = new int[(T + 1)];
            mf = new int[(T + 1)];
            vis = new boolean[(T + 1)];
            pfill(vis, vis + T, false);
        }

        int spfa() {
            queue<int> que;
            pfill(f, f + T + 1, inf);
            que.push(S);
            f[S] = 0, le[S] = -1, mf[S] = inf;
            while (!que.empty()) {
                int e = que.front();
                que.pop();
                vis[e] = false; 
                for (int i = g.h[e], eu, w; ~i; i = g[i].nx) {
                    if (!g[i].r)
                        continue;
                    eu = g[i].ed, w = f[e] + g[i].c;
                    if (w < f[eu]) {
                        f[eu] = w, le[eu] = i, mf[eu] = min(mf[e], g[i].r);
                        if (!vis[eu]) {
                            vis[eu] = true;
                            que.push(eu);
                        }
                    }
                }
            }
            if (f[T] == inf)
                return inf;
            int rt = 0;
            for (int p = T, e; ~le[p]; p = g[e ^ 1].ed) {
                e = le[p];
                g[e].r -= mf[T];
                g[e ^ 1].r += mf[T];
                rt += mf[T] * g[e].c;
            }
            return rt;
        }

        int min_cost() {
            int rt = 0, delta;
            while ((delta = spfa()) != inf) {
                rt += delta;
//                cerr << delta << '
';
            }
            return rt;
        }
} Graph;

int n;
int P, M, F, N, S;
int *require;
MapManager &g = Graph.g;

inline void init() {
    scanf("%d", &n);
    scanf("%d%d%d%d%d", &P, &M, &F, &N, &S);
    require = new int[(n + 1)];
    g = MapManager(n << 1 | 1);
    for (int i = 1; i <= n; i++) {
        scanf("%d", require + i);
    }
}

inline void solve() {
    int T = n << 1 | 1;
    Graph.set(0, T);
    for (int i = 1; i <= n; i++) {
        g.addArc(0, i, require[i], 0);
        g.addArc(0, i + n, inf, P);
        if (i < n) {
            g.addArc(i, i + 1, inf, 0);
            g.addArc(i + n, i + n + 1, inf, 0);
        }
        if (i + M <= n)
            g.addArc(i, i + n + M, inf, F);
        if (i + N <= n)
            g.addArc(i, i + n + N, inf, S);
        g.addArc(i + n, T, require[i], 0);
    }
    printf("%d
", Graph.min_cost());
}

int main() {
    init();
    solve();
    return 0;
}