BZOJ1835,LG2605 [ZJOI2010]基站选址

题意

有N个村庄坐落在一条直线上，第i(i>1)个村庄距离第1个村庄的距离为\(D_i\)

需要在这些村庄中建立不超过K个通讯基站，在第i个村庄建立基站的费用为\(C_i\)

如果在距离第i个村庄不超过\(S_i\)的范围内建立了一个通讯基站，那么就成它被覆盖了

如果第i个村庄没有被覆盖，则需要向他们补偿，费用为\(W_i\)

现在的问题是，选择基站的位置，使得总费用最小。

分析

朴素做法

用\(f(i,j)\)表示前\(i\)个村庄建了\(j\)个通讯站且第\(j\)个建在\(i\)处的最小代价，容易写出转移式

\[f(i,j)=\min_{k=1}^{i-1}\{f(k,j−1)+cost(k,i)\}+C_i
\]

其中\(cost(k,i)\)表示中间的补偿费用

然而这种做法时间是\(O(N \cdot K \cdot N)\)，空间是\(O(N^2)\)的，不可行。

优化

如果我们外层枚举\(j\)，里面枚举\(i\)呢？

很显然\(f\)的第二维和\(cost\)的第一维都可以省略。\(f\)可以用滚动，\(cost\)可以动态更新，因为变化元素的其实是有限（均摊\(O(1)\)）的。

\[f(i)=\min_{k=1}^{i-1}\{f(k)+cost(k)\}+C_i
\]

由于一个村庄\(i\)被覆盖的条件是在距离第\(i\)个村庄不超过\(S_i\)的范围内建立了一个通讯基站，因此可以发现能覆盖一个村庄的基站位置应该是一个区间。

考虑第\(i\)个村庄对于的区间\([L,R]\)，如果目前考虑的最后一个基站为\(R\)，要转移到\(R+1\)

1. 如果\(R\)处不建基站，那么对于相对\(R+1\)的上一个基站为\([1,L-1]\)的情况，都无法覆盖当前村庄，因此需要对\(cost\)的\([1,L-1]\)区间加\(W_i\)
2. 如果\(R\)处建基站，那么相当于是在相对\(R+1\)的上一个基站为\([1,R-1]\)中选择一个代价最小的，相当于对之前\(f\)和\(cost\)的和区间查询最小值

用程序的语言来讲，我们用\(st_i\)和\(ed_i\)分别表示\(i\)最左端、最右端可以覆盖到\(i\)的通讯站位置，那么我们会发现当\(ed_x=i\)时，转移到\(i+1\)时\(x\)便覆盖不到了。

我们用线段树维护\(\min\{f(k)+cost(k)\}\)，从\(f(i)\)变到\(f(i+1)\)时对于\(ed_x=i\)的\(x\),线段树中\([1,st_x−1]\)都加上\(W_x\)(加上补偿费用)即可

这样\(f\)就不用滚动了，\(cost\)也不用单独提出来。

外层循环枚举建站个数时每次重建线段树，复杂度\(O(K \cdot N \log N)\)

代码

#include<cstdlib>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<ctime>
#include<iostream>
#include<string>
#include<vector>
#include<list>
#include<deque>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<complex>
#pragma GCC optimize ("O0")
using namespace std;
template<class T> inline T read(T&x)
{
    T data=0;
	int w=1;
    char ch=getchar();
    while(!isdigit(ch))
    {
		if(ch=='-')
			w=-1;
		ch=getchar();
	}
    while(isdigit(ch))
        data=10*data+ch-'0',ch=getchar();
    return x=data*w;
}
typedef long long ll;
const int INF=0x3f3f3f3f;

const int MAXN=2e4+7;

#define lson (o<<1)
#define rson (o<<1|1)

int d[MAXN],c[MAXN],s[MAXN],w[MAXN];
int st[MAXN],ed[MAXN];
vector<int> g[MAXN];
int f[MAXN],ans;

struct SegTree
{
	int minv[MAXN<<2],addv[MAXN<<2]; // edit 3
	void pushup(int o)
	{
		minv[o]=min(minv[lson],minv[rson]);
	}
	void build(int o,int l,int r)
	{
		addv[o]=0; // edit 2
		if(l==r)
		{
			minv[o]=f[l];
			return;
		}
		int mid=(l+r)>>1;
		build(lson,l,mid);
		build(rson,mid+1,r);
		pushup(o);
	}
	void pushdown(int o)
	{
		if(addv[o])
		{
			minv[lson]+=addv[o],addv[lson]+=addv[o];
			minv[rson]+=addv[o],addv[rson]+=addv[o];
			addv[o]=0;
		}
	}
	int qmin(int o,int l,int r,int ql,int qr)
	{
		if(ql>qr)
			return 0;
//		cerr<<"query "<<o<<" "<<l<<" "<<r<<" "<<ql<<" "<<qr<<endl;
		if(ql<=l&&r<=qr)
			return minv[o];
		pushdown(o);
		int mid=(l+r)>>1,ans=INF;
		if(ql<=mid)
			ans=min(ans,qmin(lson,l,mid,ql,qr));
		if(qr>=mid+1)
			ans=min(ans,qmin(rson,mid+1,r,ql,qr));
		return ans;
	}
	void add(int o,int l,int r,int ql,int qr,int v)
	{
		if(ql>qr)
			return;
//		cerr<<"add "<<o<<" "<<l<<" "<<r<<" "<<ql<<" "<<qr<<" "<<v<<endl;
		if(ql<=l&&r<=qr)
		{
			minv[o]+=v,addv[o]+=v;
			return;
		}
		pushdown(o);
		int mid=(l+r)>>1;
		if(ql<=mid)
			add(lson,l,mid,ql,qr,v);
		if(qr>=mid+1)
			add(rson,mid+1,r,ql,qr,v);
		pushup(o);
	}
}T;

int main()
{
//  freopen(".in","r",stdin);
//  freopen(".out","w",stdout);
	int n,m;
	read(n);read(m);
	for(int i=2;i<=n;++i)
		read(d[i]);
	for(int i=1;i<=n;++i)
		read(c[i]);
	for(int i=1;i<=n;++i)
		read(s[i]);
	for(int i=1;i<=n;++i)
		read(w[i]);
	d[++n]=INF,w[n]=INF,++m;
	for(int i=1;i<=n;++i)
	{
		st[i]=lower_bound(d+1,d+n+1,d[i]-s[i])-d;
		ed[i]=lower_bound(d+1,d+n+1,d[i]+s[i])-d;
		if(d[ed[i]]>d[i]+s[i])
			--ed[i];
		g[ed[i]].push_back(i);
	}
	int t=0;
	for(int i=1;i<=n;++i)
	{
		f[i]=t+c[i];
		for(int j=0;j<g[i].size();++j)
		{
			int x=g[i][j];
			t+=w[x];
		}
	}
	ans=f[n];
	for(int i=2;i<=m;++i)
	{
		T.build(1,1,n); // edit 1
		for(int j=1;j<=n;++j)
		{
			f[j]=T.qmin(1,1,n,1,j-1)+c[j];
			for(int k=0;k<g[j].size();++k)
			{
				int x=g[j][k];
				T.add(1,1,n,1,st[x]-1,w[x]);
			}
		}
		ans=min(ans,f[n]);
	}
	printf("%d\n",ans);
//  fclose(stdin);
//  fclose(stdout);
    return 0;
}