大致题意： 有\(n\)个村庄，每个村庄有\(4\)个属性：\(D_i\)表示与村庄\(1\)的距离，\(C_i\)表示建立基站的费用，\(S_i\)表示能将其覆盖的建基站范围，\(W_i\)表示没建设基站所要付出的代价。
暴力\(DP\)
首先我们来考虑一波暴力\(DP\)。
设\(f_{i,j}\)为在前\(i\)村庄共建\(j\)个基站且第\(i\)个村庄必选所需的最小代价。
为了方便起见，我们定义它不管其之后的代价。
而这样统计答案又略显麻烦。
因此我们可以考虑在最后增加一个节点（\(++n\)即可），初始化其到村庄\(1\)的距离\(D_i\)和没建设基站所要付出的代价\(W_i\)为\(INF\)，且建立基站的费用\(C_i\)和能将其覆盖的建基站范围\(S_i\)为\(0\)。
这样初始化的好处在于，选择这个村庄不会受到前面某个村庄的影响，而选择这个村庄又不会对答案造成任何影响。
因此，这个新的节点的答案\(f_{n,k+1}\)，就是最终答案（之所以要将\(k+1\)，是因为选择这个新增的节点就相当于额外多选择了一个村庄建基站）。
而就易推得转移方程：
\]
其中\(GetW\)表示\(k\)与\(i\)之间没能被覆盖、要付出额外代价的村庄的\(W_i\)之和。
这应该比较显然，就相当于枚举一个节点\(k\)作为上个建立基站的节点，然后大力转移即可。
而\(k\)从\(j-1\)开始枚举应该也是比较显然的，因为你至少要有\(j-1\)个节点才能建\(j-1\)个基站。
然而这个式子时间复杂度差不多是\(O(N^2k)\)，压根不可能过。
所以就需要优化。
考虑优化
考虑到\(i\)与\(j\)的枚举顺序其实不会对答案造成任何影响，且\(i\)的转移显然比\(j\)的转移更容易优化。
因此，我们可以将\(j\)提出到最外面一层，从而转化得到如下式子：
\]
其中\(Lastf_k\)表示的是上一轮\(DP\)后\(f_k\)的值。
则对于这个式子，显然是要优化后面求\(min\)的这个过程。
考虑一个点在什么时候不会被覆盖。
这貌似是个智障的问题，题目中已经告诉我们，对于第\(i\)个基站，当距离它\(S_i\)范围内没有基站时，它就不会被覆盖。
则我们就可以求出\(L_x\)和\(R_x\)两个变量，分别表示最左边和最右边能覆盖到它的节点编号。（可用\(lower\_bound\)直接求，可惜我不知道如何处理一些细节问题，于是手写二分）
那么，容易发现，当你到第\(R_x+1\)个位置时，如果上一个基站的位置\(<L_x\)，则我们就需要将代价加上\(W_x\)。
于是乎就可以发现，每次代价需增加的是一段连续的区间。
也就是说，我们需要一个算法或数据结构，能够支持区间加法和区间求和两种操作。
显然线段树。
线段树优化
考虑建一棵线段树，对于每一次更新\(j\)，初始化其为\(j-1\)时的\(f\)数组。
然后，当我们操作完一个\(i\)之后，就要用所有\(R_x=i\)的\(x\)去更新选择每个点的代价。
具体操作就是在线段树上将\([j-1,L_x-1]\)这段区间权值加\(W_x\)。
而你要找到所有\(R_x=i\)的\(x\)，邻接表即可。
最后每次更新，就是在线段树中询问区间\([j-1,i-1]\)中的最小值，然后加上\(C_i\)即可得到\(f_i\)。
还有，\(j=1\)时的答案需要单独预处理。
具体实现可见代码。
代码
#include<bits/stdc++.h>
#define Tp template<typename Ty>
#define Ts template<typename Ty,typename... Ar>
#define Reg register
#define RI Reg int
#define Con const
#define CI Con int&
#define I inline
#define W while
#define N 20000
#define K 100
#define INF 1e9
#define Gmin(x,y) (x>(y)&&(x=(y)))
#define add(x,y) (e[++ee].nxt=lnk[x],e[lnk[x]=ee].to=y)
using namespace std;
int n,k,ee,d[N+5],c[N+5],s[N+5],w[N+5],L[N+5],R[N+5],f[N+5],lnk[N+5];
struct edge {int to,nxt;}e[N<<1];
class FastIO
{
private:
#define FS 100000
#define tc() (A==B&&(B=(A=FI)+fread(FI,1,FS,stdin),A==B)?EOF:*A++)
#define tn (x<<3)+(x<<1)
#define D isdigit(c=tc())
char c,*A,*B,FI[FS];
public:
I FastIO() {A=B=FI;}
Tp I void read(Ty& x) {x=0;W(!D);W(x=tn+(c&15),D);}
Ts I void read(Ty& x,Ar&... y) {read(x),read(y...);}
}F;
class SegmentTree//线段树
{
private:
#define STO l,hl,rt<<1
#define ORZ hl+1,r,rt<<1|1
#define PU(x) (O[x]=O[x<<1]+O[x<<1|1])
#define PD(x) (O[x].F&&(O[x<<1]+=O[x].F,O[x<<1|1]+=O[x].F,O[x].F=0))
int n,v[N+5];
struct Il
{
int V,F;I Il (CI v=0,CI f=0):V(v),F(f){}
I Il operator + (Con Il& t) Con {return Il(min(V,t.V));}
I void operator += (CI x) {V+=x,F+=x;}
}O[N<<2];
I void Build(CI l,CI r,CI rt)
{
if(!(l^r)) return (void)(O[rt]=Il(v[l]));
RI hl=l+r>>1;Build(STO),Build(ORZ),PU(rt);
}
I void upt(CI l,CI r,CI rt,CI ul,CI ur,CI v)//区间加法
{
if(ul<=l&&r<=ur) return O[rt]+=v;RI hl=l+r>>1;PD(rt);
ul<=hl&&(upt(STO,ul,ur,v),0),ur>hl&&(upt(ORZ,ul,ur,v),0),PU(rt);
}
I int qry(CI l,CI r,CI rt,CI ql,CI qr)//区间求和
{
if(ql<=l&&r<=qr) return O[rt].V;RI hl=l+r>>1,res=INF,t;PD(rt);
return ql<=hl&&(t=qry(STO,ql,qr),Gmin(res,t)),qr>hl&&(t=qry(ORZ,ql,qr),Gmin(res,t)),res;
}
public:
I void Init(CI x,int* s) {for(RI i=1;i<=x;++i) v[i]=s[i];Build(1,n=x,1);}
I void Update(CI l,CI r,CI v) {l<=r&&(upt(1,n,1,l,r,v),0);}
I int Query(CI l,CI r) {return l<=r?qry(1,n,1,l,r):0;}
#undef STO
#undef ORZ
}S;
I int GP(CI x)
{
RI STO=1,hl,ORZ=n;
W(STO<=ORZ) d[hl=STO+ORZ>>1]<x?(STO=hl+1):ORZ=hl-1;
return STO;
}
int main()
{
RI i,j,p,t,ans;for(F.read(n,k),i=2;i<=n;++i) F.read(d[i]);
for(i=1;i<=n;++i) F.read(c[i]);for(i=1;i<=n;++i) F.read(s[i]);for(i=1;i<=n;++i) F.read(w[i]);
for(++n,d[n]=w[n]=INF,i=1;i<=n;++i) L[i]=GP(d[i]-s[i]),R[i]=GP(d[i]+s[i]+1)-1,add(R[i],i);//初始化L[i]和R[i]，然后建边
for(t=0,i=1;i<=n;++i) for(f[i]=t+c[i],p=lnk[i];p;p=e[p].nxt) t+=w[e[p].to];ans=f[n];//预处理j=1时的答案
for(j=2;j<=k+1;++j,Gmin(ans,f[n])) for(S.Init(n,f),i=1;i<=n;++i)//枚举状态进行转移
for(f[i]=S.Query(j-1,i-1)+c[i],p=lnk[i];p;p=e[p].nxt) S.Update(j-1,L[e[p].to]-1,w[e[p].to]);//转移，并更新每个点的代价
return printf("%d",ans),0;//输出答案
}