bzoj 1835 基站选址(线段树优化Dp)

Description

题意：有N个村庄坐落在一条直线上，第i(i>1)个村庄距离第1个村庄的距离为Di题意：有N个村庄坐落在一条直线上，第 i(i>1)个村庄距离第1个村庄的距离为D_i

需要在这些村庄中建立不超过K个通讯基站，在第i个村庄建立基站的费用为Ci需要在这些村庄中建立不超过K个通讯基站，在第i个村庄建立基站的费用为C_i

如果在距离第i个村庄不超过Si的范围内建立了一个通讯基站，那么就成它被覆盖了如果在距离第i个村 庄不超过S_i的范围内建立了一个通讯基站，那么就成它被覆盖了

如果第i个村庄没有被覆盖，则需要向他们补偿，费用为Wi如果第i个村庄没有被覆盖，则需要向他们补偿，费用为W_i

现在的问题是，选择基站的位置，使得总费用最小。现在的问题是，选择基站的位 置，使得总费用最小。

Solution

首先可以想到dp,用dp[i][j]表示前i个村庄建了j个通讯站且第j个建在i处首先可以想到dp,用dp[i][j]表示前i个村庄建了j个通讯站且第j个建在i处

dp[i][j]=min(dp[k][j−1]+cost[k][i])+c[i]dp[i][j]=min(dp[k][j-1]+cost[k][i])+c[i]

cost[k][i]表示中间的补偿费用，显然我们发现可以省掉一维cost[k][i]表示中间的补偿费用，显然我们发现可以省掉一维

得到dp[i]=min(dp[k]+cost[k][i])+c[i]得到dp[i]=min(dp[k]+cost[k][i])+c[i]

那么问题来了，直接暴力搞是n3的，肯定会T辣那么问题来了，直接暴力搞是n^3的，肯定会T辣

我们外层循环枚举建通讯站的个数，里面枚举i来dp我们外层循环枚举建通讯站的个数，里面枚举i来dp

我们会发现如果做完dp[i],到了dp[i+1]的时候cost会发生变化我们会发现如果做完dp[i],到了dp[i+1]的时候cost会发生变化

而且发生变化的就是那些由于i增加而左端覆盖不到需要补偿的费用而且发生变化的就是那些由于i增加而左端覆盖不到需要补偿的费用

我们用st[i]和ed[i]分别表示i最左端、最右端可以覆盖到i的通讯站位置我们用st[i]和ed[i]分别表示i最左端、最右端可以覆盖到i的通讯站位置

那么我们会发现当ed[x]=i时，转移到i+1时x便覆盖不到了那么我们会发现当ed[x]=i时，转移到i+1时x便覆盖不到了

我们用线段树维护min(dp[k]+cost[k][i])，从dp[i]变到dp[i+1]时我们用线段树维护min(dp[k]+cost[k][i])，从dp[i]变到dp[i+1]时

对于ed[x]=i的x,线段树中[1,st[x]−1]都加上w[x](加上补偿费用)即可对于ed[x]=i的x,线段树中[1,st[x]-1]都加上w[x](加上补偿费用)即可

外层循环枚举建站个数时每次重建线段树，复杂度O(knlogn)外层循环枚举建站个数时每次重建线段树，复杂度O(knlogn)

code

#include <bits/stdc++.h>
using namespace std;
#define ls (rt << 1)
#define rs (rt << 1 | 1)
const int N = 20005, inf = ~0u >> 1;
int ans, n, m, d
, c
, s
, w
, st
, ed
, f
;
int lazy[N << 2], v[N << 2];
vector<int> g
;
inline int read(int &t) {
char c;
while (c = getchar(), c < '0' || c > '9');
t = c - '0';
while (c = getchar(), c >= '0' && c <= '9') t = t * 10 + c - '0';
return t;
}
void pushdown(int rt) {
if (lazy[rt]) {
lazy[ls] += lazy[rt], lazy[rs] += lazy[rt];
v[ls] += lazy[rt], v[rs] += lazy[rt];
lazy[rt] = 0;
}
}
inline void pushup(int rt) {
v[rt] = min(v[ls], v[rs]);
}
void build(int rt, int l, int r) {
lazy[rt] = 0;
if (l == r) {
v[rt] = f[l];
return;
}
int mid = l + r >> 1;
build(ls, l, mid), build(rs, mid + 1, r);
pushup(rt);
}
void change(int rt, int l, int r, int L, int R, int x) {
if (L > R)  return;
if (L <= l && R >= r) {
lazy[rt] += x;
v[rt] += x;
return;
}
pushdown(rt);
int mid = l + r >> 1;
if (L <= mid)   change(ls, l, mid, L, R, x);
if (R > mid)    change(rs, mid + 1, r, L, R, x);
pushup(rt);
}
int ask(int rt, int l, int r, int L, int R) {
if (L > R)  return 0;
if (L <= l && R >= r)   return v[rt];
int mid = l + r >> 1;
pushdown(rt);
int t = inf;
if (L <= mid)   t = min(t, ask(ls, l, mid, L, R));
if (R > mid)    t = min(t, ask(rs, mid + 1, r, L, R));
return t;
}
void init() {
read(n), read(m);
for (int i = 2; i <= n; ++i)    read(d[i]);
for (int i = 1; i <= n; ++i)    read(c[i]);
for (int i = 1; i <= n; ++i)    read(s[i]);
for (int i = 1; i <= n; ++i)    read(w[i]);
d[++n] = inf, w
= inf, ++m;
for (int i = 1; i <= n; ++i) {
st[i] = lower_bound(d + 1, d + n + 1, d[i] - s[i]) - d;
ed[i] = lower_bound(d + 1, d + n + 1, d[i] + s[i]) - d;
if (d[ed[i]] > d[i] + s[i]) --ed[i];
g[ed[i]].push_back(i);
}
}
void gao() {
ans = inf;
for (int i = 1; i <= m; ++i) {
if (i == 1) {
int t = 0;
for (int j = 1; j <= n; ++j) {
f[j] = t + c[j];
for (int k = 0; k < g[j].size(); ++k) {
int x = g[j][k];
t += w[x];
}
}
ans = f
;
continue;
}
build(1, 1, n);
for (int j = 1; j <= n; ++j) {
f[j] = ask(1, 1, n, 1, j - 1) + c[j];
for (int k = 0; k < g[j].size(); ++k) {
int x = g[j][k];
change(1, 1, n, 1, st[x] - 1, w[x]);
}
}
ans = min(ans, f
);
}
}
int main() {
init();
gao();
printf("%d\n", ans);
return 0;
}