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;
}