基站选址
题目链接:ybt金牌导航1-2-2 / luogu P2605
题目大意
一条直线上要在点上建一些基站,数量不能超过一个数,一个地方 i 会被基站覆盖仅当不超过 S[i] 的范围内有基站。
然后在一个地方建基站有一个花费,一个地方没有被基站覆盖也有一个补偿费用。
给出直线上点之间的位置距离,问你最小花费。
思路
这道题首先我们可以想想最垃圾的 dp 怎么打。
考虑
f
i
,
j
f_{i,j}
fi,j 为前
i
i
i 个点中最后选的是
i
i
i 号点,一共选了
j
j
j 个点的最小花费。(而且是只考虑
1
∼
i
1\sim i
1∼i 的花费,不管
i
+
1
∼
n
i+1\sim n
i+1∼n 的赔偿费用)
那可以搞出转移方程:
f
i
,
j
=
min
{
f
k
,
j
−
1
+
p
a
y
k
,
i
}
+
c
i
(
j
−
1
≤
k
<
i
)
。
f_{i,j}=\min\{f_{k,j-1}+pay_{k,i}\}+c_i(j-1\leq k<i)。
fi,j=min{fk,j−1+payk,i}+ci(j−1≤k<i)。
我们看到每次第二位只是调用前面的一个,那我们可以把第二位去掉。
那空间就可以了,但是时间还是
O
(
n
2
k
)
O(n^2k)
O(n2k),还是会超时(因为你要
O
(
n
)
O(n)
O(n) 算
p
a
y
k
,
i
pay_{k,i}
payk,i)。
那我们考虑优化这个地方。
首先,对于一个点,你可以求出要使它被覆盖,哪个区间内必须至少建一个基站。这个可以用二分快速解决。然后每个点都要求,那就是
O
(
n
l
o
g
n
)
O(nlogn)
O(nlogn)。
假设已经求了出来,左边界是
g
l
i
gl_i
gli,右边界是
g
r
i
gr_i
gri。
那我们考虑枚举
i
i
i 的时候,怎么转。
分两种情况。
首先是选,这个是要统计到
f
i
f_i
fi 里面的。那上一个基站就在
1
∼
i
−
1
1\sim i-1
1∼i−1 之间,那我们就在这些地方选最小值。
当然你不能直接枚举看,我们考虑用一个数据结构来优化。由于数是不停变化的,那我们考虑用线段树。
接着是不选,这个是留在给后面用的,那你就要考虑赔偿,那你要看哪些点要开始赔偿。
那如果这个不选了,临界的点就会碰不到了。那如果有一个点 x x x,它的 g r x gr_x grx 就是 i i i,那如果不选了 i i i,选 i + 1 i+1 i+1 或者更加以后的,就都覆盖不到这个点了,这个点也就要赔偿了。
那你只要用邻接表记录右边界为它的点,然后在从
1
1
1 到左边界的左边加上赔偿费用即可。
为什么是左边界的左边?
因为是左边界的左边,才会两边都没有基站,才要赔偿。(就是你建在左边界的左边,新的又不建,就要赔偿)
这个就是区间加值,也可以用线段树来做。
但是有一个问题,你每次只会解决它和它前面的,它后面的你还没看。
那你就在最后的点后面多开一个点,只会覆盖到它自己,而且没有费用,也不会被任何点覆盖。
那我们跑这个点的时候,就会把所有的边再看一次,就可以了。
代码
#include<cstdio>
#include<iostream>
#define ll long long
#define INF 0x3f3f3f3f3f3f3f3f
using namespace std;
struct node {
int to, nxt;
}e[40010];
struct Tree {
ll x, lazy;
}tree[160010];
int n, k, c[20010], w[20010];
int gl[20010], gr[20010];
int le[20010], KK;
ll d[20010], s[20010], f[20010], ans;
void add(int x, int y) {
e[++KK] = (node){y, le[x]}; le[x] = KK;
}
void ef(int now) {
int l = 0, r = now - 1;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (d[now] - d[now - mid] <= s[now]) l = mid;
else r = mid - 1;
}
gl[now] = now - l;//左边界
l = 0, r = n - now;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (d[now + mid] - d[now] <= s[now]) l = mid;
else r = mid - 1;
}
gr[now] = now + l;//右边界
add(gr[now], now);//记录那些点的右边界是这个点
}
void gotfirst() {
ll now = 0;
for (int i = 1; i <= n; i++) {
f[i] = now + c[i];//在这里建
for (int j = le[i]; j; j = e[j].nxt)
now += w[e[j].to];//如果不在这里建,有那些点要开始赔偿
}
}
void up(int now) {//线段树操作
tree[now].x = min(tree[now << 1].x, tree[now << 1 | 1].x);
}
void down(int now) {
tree[now << 1].x += tree[now].lazy;
tree[now << 1 | 1].x += tree[now].lazy;
tree[now << 1].lazy += tree[now].lazy;
tree[now << 1 | 1].lazy += tree[now].lazy;
tree[now].lazy = 0;
}
void build(int now, int l, int r) {
tree[now].lazy = 0;
if (l == r) {
tree[now].x = f[l];
return ;
}
int mid = l + ((r - l) >> 1);
build(now << 1, l, mid);
build(now << 1 | 1, mid + 1, r);
up(now);
}
ll get_ans(int now, int l, int r, int L, int R) {//得到费用最小的那个
if (L > R) return INF;
if (l >= L && r <= R) return tree[now].x;
down(now);
int mid = l + ((r - l) >> 1);
ll re = INF;
if (L <= mid) re = min(re, get_ans(now << 1, l, mid, L, R));
if (R >= mid + 1) re = min(re, get_ans(now << 1 | 1, mid + 1, r, L, R));
return re;
}
void add_num(int now, int l, int r, int L, int R, ll addnum) {
if (L > R) return ;
if (L <= l && R >= r) {
tree[now].x += addnum;
tree[now].lazy += addnum;
return ;
}
down(now);
int mid = l + ((r - l) >> 1);
if (L <= mid) add_num(now << 1, l, mid, L, R, addnum);
if (R >= mid + 1) add_num(now << 1 | 1, mid + 1, r, L, R, addnum);
up(now);
return ;
}
void work() {
gotfirst();//预处理出一开始的情况
ans = f[n];
for (int i = 2; i <= k; i++) {
build(1, 1, n);//记录原来的位置
for (int j = 1; j <= n; j++) {
f[j] = c[j] + get_ans(1, 1, n, 1, j - 1);//选
for (int I = le[j]; I; I = e[I].nxt)//不选
add_num(1, 1, n, 1, gl[e[I].to] - 1, w[e[I].to]);
}
ans = min(ans, f[n]);
}
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 2; i <= n; i++) scanf("%lld", &d[i]);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
for (int i = 1; i <= n; i++) scanf("%lld", &s[i]);
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
n++;
k++;
d[n] = INF;
w[n] = INF;
//这里在最后多加一个点,在这里建覆盖不到其他点,而且不会被任何点覆盖,建基站也没有费用
//这样其实就可以考虑到前面每个正常的基站对后面的影响
//因为你每次考虑只会考虑这个基站对它和前面的影响,以及前面的基站对它和它前面的影响
//那你最后一个基站的后面就不会被考虑,就需要再多弄一个点,使得没有遗漏
for (int i = 1; i <= n; i++) {
ef(i);
}//二分出能覆盖到它的位置的左右边界
work();//线段树优化dp
printf("%lld", ans);
return 0;
}