[BZOJ1835][ZJOI2010]base 基站选址

base 基站选址

Description

有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。

Input

输入文件的第一行包含两个整数N,K，含义如上所述。
第二行包含N-1个整数，分别表示D2,D3,…,DN ，这N-1个数是递增的。
第三行包含N个整数，表示C1,C2,…CN。
第四行包含N个整数，表示S1,S2,…,SN。
第五行包含N个整数，表示W1,W2,…,WN。

Output

输出文件中仅包含一个整数，表示最小的总费用。

Sample Input

3 2
1 2
2 3 2
1 1 0
10 20 30

Sample Output

4

HINT

40%的数据中，N<=500；
100%的数据中，K <= N，K <= 100，N <= 20,000，Di <= 1000000000，Ci <= 10000，Si <= 1000000000，Wi <= 10000。

---

这道题的dp是如此好想……
然而打完后却发现要用线段树优化……
写完线段树然后就被long long 坑了一晚上……

(╯‵□′)╯︵┻━┻

---

思路:
设f[i][j]表示到第i个村庄用了j台基站，其中第j台基站在i的最小花费。
咱可以得到一个式子:
f[i][j]=min(f[k][j-1]+cost(k,i))+c[i]
其中cost(k,i)为k到i之间不建基站所需的补偿代价~

然后，事实上如果这题不是省选题而是NOIP题的话说不定就直接暴力枚举好了~
然而咱必须面对一个残酷的现实:它不是。
所以，首先很明显第二维可以滚动掉。
然后，f+cost可以用一个线段树维护，降复杂度。
然后，没有了~

具体实现:
先预处理l[i]和r[i]表示在l[i]和r[i]两村之间的任意村庄建站，i号村庄都不用交补偿的最远的两个村庄的编号，可以用lower_bound或二分~
接着咱就DP~
外层循环滚动第二维……
顺序枚举第一维，每枚举完一个村就把所有r[i]是当前枚举村的村庄的w[i]加入线段树的[1,l[i]-1]区间中。
这是因为咱枚举的村庄是从小到大的，对于一个村庄如果咱已经走过了其r[i]，则在对后续的村庄暴力枚举min时咱如果匹配到的k < l[i]，则当前节点必对答案有一个w[i]的增幅，因为l[i]到r[i]这一段没有任何的基站，上一个基站小于l[i]，这一个又大于r[i],自然要补偿了。

线段树的话维护一个区间最小值就好~

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>

using namespace std;

#define mo puts("mo");
#define ha puts("ha");

typedef long long ll;

const int N=200233;
const int Inf=1000000000;

int n,k;
int d[N],c[N],s[N],w[N];
int l[N],r[N];
ll f[N];
int nxt[N],beg[N];

inline void push(int u,int v)
{
    nxt[v]=beg[u];
    beg[u]=v;
}

inline int read()
{
    int x=0;char ch=getchar();
    while(ch<'0' || '9'<ch)ch=getchar();
    while('0'<=ch && ch<='9')
    {
        x=(x<<1)+(x<<3)+(ch^48);
        ch=getchar();
    }
    return x;
}

struct segment_tree
{
    ll t[N<<2],tag[N<<2];

    inline void update(int n)
    {
        t[n]=min(t[n<<1],t[n<<1|1]);
    }

    inline void push(int n)
    {
        t[n<<1]+=tag[n];
        t[n<<1|1]+=tag[n];
        tag[n<<1]+=tag[n];
        tag[n<<1|1]+=tag[n];
        tag[n]=0;
    }

    void biu(int n,int l,int r)
    {
        tag[n]=0;
        if(l==r)
        {
            t[n]=f[l];
            return;
        }

        int mid=l+r>>1;
        biu(n<<1,l,mid);
        biu(n<<1|1,mid+1,r);
        update(n);
    }

    void add(int n,int l,int r,int dl,int dr,ll val)
    {
        if(dl>dr)
            return;
        if(l==dl && r==dr)
        {
            t[n]+=val;
            tag[n]+=val;
            return;
        }

        push(n);
        int mid=l+r>>1;
        if(dr<=mid)
            add(n<<1,l,mid,dl,dr,val);
        else if(mid<dl)
            add(n<<1|1,mid+1,r,dl,dr,val);
        else
            add(n<<1,l,mid,dl,mid,val),
            add(n<<1|1,mid+1,r,mid+1,dr,val);
        update(n);
    }

    ll query(int n,int l,int r,int dl,int dr)
    {
        if(dl>dr)
            return 0;
        if(l==dl && r==dr)
            return t[n];

        push(n);
        int mid=l+r>>1;
        if(dr<=mid)
            return query(n<<1,l,mid,dl,dr);
        if(mid<dl)
            return query(n<<1|1,mid+1,r,dl,dr);
        return min(query(n<<1,l,mid,dl,mid),query(n<<1|1,mid+1,r,mid+1,dr));
    }
}koishi;

inline int find(int pos)
{
    int l=1,r=n,mid,ans;
    if(pos<=0)
        return 0;
    while(l<=r)
    {
        mid=l+r>>1;
        if(d[mid]<pos)
            ans=mid,l=mid+1;
        else
            r=mid-1;
    }

    return ans;
}

inline ll dp()
{
    ll ans=Inf,tmp=0;
    for(int i=1;i<=n;i++)
    {
        f[i]=(ll)(tmp+c[i]);
        for(int j=beg[i];j;j=nxt[j])
            tmp+=w[j];
    }

    ans=f[n];
    for(int i=2;i<=k;i++)
    {
        koishi.biu(1,1,n);

        for(int j=1;j<=n;j++)
        {
            f[j]=koishi.query(1,1,n,1,j-1)+c[j];
            for(int k=beg[j];k;k=nxt[k])
                koishi.add(1,1,n,1,l[k],w[k]);
        }

        ans=min(ans,f[n]);
    }

    return ans;
}

int main()
{
    n=read();k=read();

    for(int i=2;i<=n;i++)
        d[i]=read();
    for(int i=1;i<=n;i++)
        c[i]=read();
    for(int i=1;i<=n;i++)
        s[i]=read();
    for(int i=1;i<=n;i++)
        w[i]=read();

    n++;k++;
    d[n]=Inf;w[n]=Inf;

    for(int i=1;i<=n;i++)
    {
        l[i]=find(d[i]-s[i]);
        r[i]=find(d[i]+s[i]);

        if(d[r[i]+1]==d[i]+s[i])
            r[i]++;

        push(r[i],i);
    }

    printf("%lld\n",dp());

    return 0;
}