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

Input
输入数据 (base.in) 输入文件的第一行包含两个整数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

分析：
设f[i]为在第i个村庄建通讯基站时的最小花费

则f[i]=min{f[j]+cost[j][i]}+c[i],1<=j<=i-1

cost[j][i]表示最后两个基站分别建在j和i时对于中间村庄的补偿W之和
暴力求cost[j][i]的话，时间复杂度会达到O(n^3)，对于本题的数据规模来说是不令人满意的

假如f[j]与cost[j][i]为定值的话，显然可以用数据结构来维护min(f[j]+cost[j][i])
维护区间信息，我们一下子就想到了线段树

然而当i变为i+1时，cost[j][i]的值会变更，因为此时的基站的位置改变，需要给出的补偿也会改变
那么这个变化显然是由原来被i覆盖的村庄所影响的，

设l[x],r[x]表示在[l[x],r[x]]范围内建造基站村庄x能被覆盖

所以我们可以计算出每个村庄可以被覆盖的左端点与右端点l与r，

每次处理完x位置,枚举所有r[a]=x的村庄a,然后在线段树中把[1,l[a]-1]都加上w[a]
(在l[a]之前建一座基站覆盖不到a，花费要加上w，第二座基站在r[a]覆盖了a)

此外，由于答案最优时不一定需要在最后一个点建基站，我们可以新增一个点，
w[++n]=+oo,c[n]=0,++k
这样子就可以保证答案一定是f[n]

最外层循环基站个数从1到k时注意每次保留最优解，因为不一定建k个基站是最优的

最后总结一下写这个代码时犯的错误：

if (d[r[i]]>d[i]+s[i]) r[i]–;
//r[i]和l[i]记录的都是村庄的编号，而比较的时候比较的是距离

不会用lower_bound,vector

输出的变量写错(超zz)

ask，add时没有特判l>r的情况
//在处理第一个和最后一个时很有可能出现这种情况

tree[bh].lazy=0;
//最玄学的错误,因为是重构线段树，所以经过的每一个线段树的节点的标记都要清零

这里写代码片
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>using namespace std;const int INF=0x33333333;
const int N=100010;
int n,k;
int d[N],c[N],s[N],w[N],l[N],r[N],f[N];
struct node{int x,y,mn,lazy;
};
node tree[N<<2];
vector<int> g[N];
int ans;inline void update(int bh)
{tree[bh].mn=min(tree[bh<<1].mn,tree[bh<<1|1].mn);
}inline void push(int bh)
{if (tree[bh].lazy&&tree[bh].x!=tree[bh].y){int lc=bh<<1;int rc=bh<<1|1;tree[lc].lazy+=tree[bh].lazy;tree[rc].lazy+=tree[bh].lazy;tree[lc].mn+=tree[bh].lazy;  //最小花费 tree[rc].mn+=tree[bh].lazy;tree[bh].lazy=0;}return;
}void build(int bh,int l,int r)
{tree[bh].x=l;tree[bh].y=r;tree[bh].lazy=0;  //if (l==r){tree[bh].mn=f[l];return;}int mid=(l+r)>>1;build(bh<<1,l,mid);build(bh<<1|1,mid+1,r);update(bh);
}int ask(int bh,int l,int r)
{if (l>r) return 0;  //特判push(bh);if (tree[bh].x>=l&&tree[bh].y<=r){return tree[bh].mn;}int ans=1000010;int mid=(tree[bh].x+tree[bh].y)>>1;if (l<=mid) ans=min(ans,ask(bh<<1,l,r));if (r>mid) ans=min(ans,ask(bh<<1|1,l,r));return ans;
}void add(int bh,int l,int r,int z)
{if (l>r) return;  // push(bh);if (tree[bh].x>=l&&tree[bh].y<=r){tree[bh].mn+=z;tree[bh].lazy+=z;return;}int mid=(tree[bh].x+tree[bh].y)>>1;if (l<=mid) add(bh<<1,l,r,z);if (r>mid) add(bh<<1|1,l,r,z);update(bh);    ///
}void doit()
{int i,j;for (i=1;i<=k;i++)   //外层循环基站个数{if (i==1){int t=0;for (j=1;j<=n;j++){f[j]=t+c[j];int sz=g[j].size()-1;for (int s=0;s<=sz;s++) t+=w[g[j][s]];  //r[i]=j//动态数组从0开始记录 }ans=f[n];  //每次循环的答案都记录在f[n] continue;}build(1,1,n);  //每次dp就要重构，维护f[j]+cost[j][s];for (j=1;j<=n;j++){f[j]=ask(1,1,j-1)+c[j];   //询问在j之前的最优状态 int sz=g[j].size()-1;  //r==g[j]for (int s=0;s<=sz;s++)add(1,1,l[g[j][s]]-1,w[g[j][s]]);  //r[g[j][s]]==j}ans=min(ans,f[n]);} printf("%d",ans);
}int main()
{scanf("%d%d",&n,&k);k++;  //在末尾增加一个基站 for (int i=2;i<=n;i++) scanf("%d",&d[i]);for (int i=1;i<=n;i++) scanf("%d",&c[i]);for (int i=1;i<=n;i++) scanf("%d",&s[i]);for (int i=1;i<=n;i++) scanf("%d",&w[i]);d[++n]=INF;w[n]=INF;//lower_bound大于等于value 的值for (int i=1;i<=n;i++){l[i]=lower_bound(d+1,d+1+n,d[i]-s[i])-d;r[i]=lower_bound(d+1,d+1+n,d[i]+s[i])-d;  //l,r记录的都是编号，至少在l[i]|r[i]建基站i才能被覆盖 if (d[r[i]]>d[i]+s[i]) r[i]--;  //计算距离i村庄最近的基站至少要在哪里 //这里之所以有这个操作是因为我们用的是lower_bound g[r[i]].push_back(i);  //g[x] r[i]==x的村庄编号 }doit();return 0;
}