大致题意： 有(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;//输出答案
}