【BZOJ 1835】base 基站选址:线段树优化DP

题目描述

有N个村庄坐落在一条直线上，第i(i>1)个村庄距离第1个村庄的距离为Di。需要在这些村庄中建立不超过K个通讯基站，在第i个村庄建立基站的费用为Ci。如果在距离第i个村庄不超过Si的范围内建立了一个通讯基站，那么就成它被覆盖了。如果第i个村庄没有被覆盖，则需要向他们补偿，费用为Wi。现在的问题是，选择基站的位置，使得总费用最小。 输入数据 (base.in) 输入文件的第一行包含两个整数N,K，含义如上所述。 第二行包含N-1个整数，分别表示D2,D3,…,DN ，这N-1个数是递增的。 第三行包含N个整数，表示C1,C2,…CN。 第四行包含N个整数，表示S1,S2,…,SN。 第五行包含N个整数，表示W1,W2,…,WN。

分析

写完这道题本菜鸡发出了没见过世面的声音：妙啊

首先想一个状态表示$f[i][k]$，第$i$位为必选状态，目前已经建立了$k$个基站，不考虑$i+1$后面的情况的话，那么状态转移方程就是
$f[i][j]=min(f[i][j],f[k][j-1]+cost(k,i))$
$cost$为中间这个区间没有被覆盖，需要赔偿的费用，很容易看出来这是一个$n^3$的复杂度了，明显是过不去的
我们思考一下怎么去优化这个DP
我们需要在$1～i-1$的范围内找到最小的$f[k][j-1]+cost(k,i)$去进行状态转移，联想一下我们学过的单调队列优化DP，我们可不可以用一些数据结构去动态维护这个值并且实现区间查找功能呢？
答案已经呼之欲出了，那就是用线段树去维护
怎么去维护，假设每个点的控制范围为$l[i],r[i]$，那么每当我们走过一个节点的时候，把不能被覆盖的区间进行区间修改，加上他们的补偿费用即可
因为我们的状态定义是在$i$点必须有一个基站，所以我们可以多设一个虚点，再这个点再建一个基站，方便答案统计

代码

#pragma GCC optimize(3)
#include <bits/stdc++.h>
#define debug(x) cout<<#x<<":"<<x<<endl;
#define dl(x) printf("%lld\n",x);
#define di(x) printf("%d\n",x);
#define _CRT_SECURE_NO_WARNINGS
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> PII;
typedef vector<int> VI;
const int INF = 0x3f3f3f3f;
const int N = 2e5 + 10;
const ll mod = 1000000007;
const double eps = 1e-9;
const double PI = acos(-1);
template<typename T>inline void read(T &a) {
    char c = getchar(); T x = 0, f = 1; while (!isdigit(c)) {if (c == '-')f = -1; c = getchar();}
    while (isdigit(c)) {x = (x << 1) + (x << 3) + c - '0'; c = getchar();} a = f * x;
}
int gcd(int a, int b) {return (b > 0) ? gcd(b, a % b) : a;}
int d[N],s[N];
int c[N],w[N];
int n,k;
int st[N],ed[N];
VI num[N];
int f[N];

struct Node{
    int l,r,x,add;
}tr[N << 2];

void pushup(int u){
    tr[u].x = min(tr[u << 1].x,tr[u << 1 | 1].x);
}

void build(int u,int l,int r){
    tr[u].l = l,tr[u].r = r;
    if(l == r){
        tr[u].x = f[l];
        tr[u].add = 0;
        return;
    }
    int mid = l + r >> 1;
    build(u << 1,l,mid),build(u << 1 | 1,mid + 1,r);
    pushup(u);
    tr[u].add = 0;
}

void down(int u){
    if(tr[u].add){
        tr[u << 1].x += tr[u].add;
        tr[u << 1 | 1].x += tr[u].add;
        tr[u << 1].add += tr[u].add;
        tr[u << 1 | 1].add += tr[u].add;
    }
    tr[u].add = 0;
}

int query(int u,int l,int r){
    if(l > r) return 0;
    if(tr[u].l >= l && tr[u].r <= r) return tr[u].x;
    down(u);
    int res = INF;
    int mid = tr[u].l + tr[u].r >> 1;
    if(l <= mid) res = query(u << 1,l,r);
    if(r > mid) res = min(res,query(u << 1 | 1,l,r));
    return res;
}

void modify(int u,int l,int r,int x){
    if(l > r) return;
    if(tr[u].l >= l && tr[u].r <= r){
        tr[u].x += x;
        tr[u].add += x;
        return;
    }
    down(u);
    int mid = tr[u].l + tr[u].r >> 1;
    if(l <= mid) modify(u << 1,l,r,x);
    if(r > mid) modify(u << 1 | 1,l,r,x);
    pushup(u);
}

int main() {
    read(n),read(k);
    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]);
    n++,k++;
    d[n] = 1e9;
    for(int i = 1;i <= n;i++){
        st[i] = lower_bound(d + 1,d + 1 + n,d[i] - s[i]) - d;
        ed[i] = lower_bound(d + 1,d + 1 + n,d[i] + s[i]) - d;
        if(d[ed[i]] > d[i] + s[i]) ed[i]--;
        num[ed[i]].pb(i);
    }
    int ans = INF;
    for(int i = 1;i <= k;i++){
        if(i == 1){
            int t = 0;
            for(int j = 1;j <= n;j++){
                f[j] = t + c[j];
                for(int l = 0;l < num[j].size();l++){
                    int p = num[j][l];
                    t += w[p];
                }
            }
            ans = f[n];
            continue;
        }
        build(1,1,n);
        for(int j = 1;j <= n;j++){
            f[j] = query(1,1,j - 1) + c[j];
            for(int l = 0;l < num[j].size();l++){
                int p = num[j][l];
                modify(1,1,st[p] - 1,w[p]);
            }
        }
        ans = min(ans,f[n]);
    }
    di(ans);
    return 0;
}

/**
*　　┏┓　　　┏┓+ +
*　┏┛┻━━━┛┻┓ + +
*　┃　　　　　　　┃
*　┃　　　━　　　┃ ++ + + +
*  ████━████+
*  ◥██◤　◥██◤ +
*　┃　　　┻　　　┃
*　┃　　　　　　　┃ + +
*　┗━┓　　　┏━┛
*　　　┃　　　┃ + + + +Code is far away from 　
*　　　┃　　　┃ + bug with the animal protecting
*　　　┃　 　 ┗━━━┓ 神兽保佑,代码无bug　
*　　　┃ 　　　　　　 ┣┓
*　　  ┃ 　　　　　 　┏┛
*　    ┗┓┓┏━┳┓┏┛ + + + +
*　　　　┃┫┫　┃┫┫
*　　　　┗┻┛　┗┻┛+ + + +
*/