bzoj 1835 base 基站选址

题目传送门

　　需要高级权限的传送门

题目大意

　　有$n$个村庄坐落在一条直线上，第$i (i>1)$个村庄距离第$1$个村庄的距离为$D_i$。需要在这些村庄中建立不超过$K$个通讯基站，在第$i$个村庄建立基站的费用为$C_i$。如果在距离第$i$个村庄不超过$S_i$的范围内建立了一个通讯基站，那么就成它被覆盖了。如果第$i$个村庄没有被覆盖，则需要向他们补偿，费用为$W_i$。现在的问题是，选择基站的位置，使得总费用最小。 

　　三方dp是显然的，用$f_{i, j}$表示考虑前$i$个村庄，在第$i$个村庄建立基站的最小费用。

　　预处理一下，每个村庄距离不超过$S_i$的村庄区间。然后考虑用某个数据结构来维护转移。

　　将这些区间按照右端点排序，当当前考虑的$i$大于这个区间的右端点的时候，那么这个区间的左端点以前的状态的转移需要加上它的赔偿费用。

　　然后就做完了。时间复杂度$O(nklog n)$

Code

/**
 * bzoj
 * Problem#1835
 * Accepted
 * Time: 2468ms
 * Memory: 11300k
 */
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <queue>
using namespace std;
typedef bool boolean;
#define ll long long

const signed int inf = (signed) (~0u >> 2);
const int N = 2e4 + 5, Kmx = 105;

typedef class Segment {
    public:
        int l, r, cost;

        boolean operator < (Segment s) const {
            return r < s.r;
        }
}Segment;

typedef class SegTreeNode {
    public:
        int val, tg;
        SegTreeNode *l, *r;

        void pushUp() {
            val = (l->val < r->val) ? (l->val) : (r->val);
        }

        void pushDown() {
            l->val += tg, l->tg += tg;
            r->val += tg, r->tg += tg;
            tg = 0;
        }
}SegTreeNode;

SegTreeNode pool[N << 2];
SegTreeNode *top;

SegTreeNode* newnode() {
    top->val = inf, top->tg = 0;
    top->l = top->r = NULL;
    return top++;    
}

typedef class SegTree {
    public:
        int n;
        SegTreeNode* rt;

        SegTree() {    }
        SegTree(int n):n(n) {
            top = pool;
            build(rt, 1, n);
        }

        void build(SegTreeNode*& p, int l, int r) {
            p = newnode();
            if (l == r)
                return;
            int mid = (l + r) >> 1;
            build(p->l, l, mid);
            build(p->r, mid + 1, r);
        }

        void update(SegTreeNode* p, int l, int r, int ql, int qr, int val) {
            if (ql == l && r == qr) {
                p->val += val;
                p->tg += val;
                return;
            }
            if (p->tg)
                p->pushDown();
            int mid = (l + r) >> 1;
            if (qr <= mid)
                update(p->l, l, mid, ql, qr, val);
            else if (ql > mid)
                update(p->r, mid + 1, r, ql, qr, val);
            else {
                update(p->l, l, mid, ql, mid, val);
                update(p->r, mid + 1, r, mid + 1, qr, val);
            }
            p->pushUp();
        }

        void update(SegTreeNode* p, int l, int r, int idx, int val) {
            if (l == r) {
                p->val = val;
                return;
            }
            if (p->tg)
                p->pushDown();
            int mid = (l + r) >> 1;
            if (idx <= mid)
                update(p->l, l, mid, idx, val);
            else
                update(p->r, mid + 1, r, idx, val);
            p->pushUp();
        }

        int query() {
            return rt->val;
        }

        void update(int l, int r, int val) {
            if (l > r)
                return;
            update(rt, 1, n, l, r, val);
        }
        
        void update(int p, int val) {
            update(rt, 1, n, p, val);
        }
}SegTree;

int n, K, tp = 0;
int dist[N], cost[N], rang[N];
int comp[N];
int f[Kmx][N];
Segment sgs[N];
SegTree st;

inline void init() {
    scanf("%d%d", &n, &K);
    dist[1] = 0;
    for (int i = 2; i <= n; i++)
        scanf("%d", dist + i);
    for (int i = 1; i <= n; i++)
        scanf("%d", cost + i);
    for (int i = 1; i <= n; i++)
        scanf("%d", rang + i);
    for (int i = 1; i <= n; i++)
        scanf("%d", comp + i);
}

int res = 0;
inline void solve() {
    for (int i = 1; i <= n; i++) {
        int l = dist[i] - rang[i], r = dist[i] + rang[i];
        sgs[i].l = lower_bound(dist + 1, dist + i + 1, l) - dist;
        sgs[i].r = upper_bound(dist + i, dist + n + 1, r) - dist - 1;
        sgs[i].cost = comp[i];
    }
    
    sort(sgs + 1, sgs + n + 1);

    for (int i = 1; i <= n; i++)
        res += comp[i];
    if (!K) {
        printf("%d", res);
        return;
    }
    
    int costs = 0;
    Segment* p = sgs + 1, *ped = sgs + n + 1;
    for (int i = 1; i <= n; i++) {
        f[1][i] = costs + cost[i];
        while (p != ped && p->r <= i)
            costs += p->cost, p++;
    }

    for (int k = 1; k <= K; k++) {
        st = SegTree(n);
        p = sgs + 1;
        for (int i = 1; i <= n; i++) {
            f[k + 1][i] = st.query() + cost[i];
            while (p != ped && p->r <= i)
                st.update(1, p->l - 1, p->cost), p++;
            st.update(i, f[k][i]);
        }
        res = min(res, st.query());
    }
    printf("%d", res);
}

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