分析样例可以知道:
当X=1时,我们要选择[1,N]内能够产生最大疲劳度的点;
当X=2时,我们在X=1的方案的基础上,继续从[1,N]内选出产生疲劳度最大的点,注意这个时候整个区间都要进行更新,假设X=1时选中的点为x1,则x1不能再选,可以修改为0,对于[1,x1-1],距离因素不再考虑,对于[x1+1,N],距离因素产生的疲劳度都要减去2*d[x1](d[i]表示第i家住户到入口的距离);
当X=3,4,…,N时,方案与上面的相同。
于是我们可以得出结论:
1.我们每次都要选取当前[1,N]内贡献最大的点,且第i次选择的方案是在第i-1次的方案上去选的,这就是贪心;
2.每次选完之后,[1,N]都会进行更新,也就是说,我们要动态的选择区间最大值。
与区间有关的我们容易想到线段树,而区间的更新方式也在上面已经提及,那么每次更新主要有两个部分:
设当前方案选中的是k点,则
1.k点的贡献修改为0,不再考虑k点的贡献;
2.[1,k-1]所有点减去距离的贡献;
3.[k+1,N]所有点的贡献减去2*d[k]。
第1点容易实现,但是第2点和第3点似乎不太方便,因为每次选了某个点之后就要更新其余所有的点,相当于整个区间都更新了一次,这样显然是会超时的,有什么优化的方案吗?有!关于第2点,其实我们并没有必要每次选完都更新!假设上一次选中的点为k0,这一次选中的点为k1,那么如果k1<k0,就完全没有必要更新[1,k1-1],而如果k1>k0,我们也只要更新[k0+1,k1-1]而已!因此我们可以设置一个变量,记录目前为止方案里面距离最远的点的编号dis,每次选完后把选中的点与它进行比较,对它更新就好了,这样一来,总的来说,操作2只会对每个点更新一次,而线段树单点更新的时间复杂度为logN,因此最后操作2总的时间复杂度为NlogN!
那么操作3又该怎么优化呢?操作3没法再更新上面进行优化,但其实仔细一想我们也没有必要更新,因为[dis+1,N]所有点的贡献都是减去2*d[dis],所以[dis+1,N]内的最大值还是原来的最大值,因此我们没有必要对[dis+1,N]进行更新。但是,因为[1,dis-1],[dis+1,N]两个区间内的点的贡献都已经发生了变化,所以我们在线段树push_up函数中比较两区间的最大值的时候,要做一些改变,这会在代码中讲解。
代码如下:
#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<stack>
#include<cstring>
using namespace std;
typedef long long ll;
const int maxn=1e5+5;
int a[maxn],d[maxn],dis; //a[i]:表示第i个点对疲劳度的贡献,d[i]为距离,dis记录目前为止方案中距离最远的点
struct Node
{
int l,r;
int max_id; //记录的是最大值的编号
}tr[maxn<<2];
void push_up(int rt)
{
int t1=a[tr[rt<<1].max_id], t2=a[tr[rt<<1|1].max_id]; //t1为左子树对应区间的最大值,t2为右子树
if(tr[rt<<1].max_id>=dis) t1-=2*d[dis];//如果左子树的最大值的编号落在[dis+1,N],那么就要减去相应的贡献
if(tr[rt<<1|1].max_id>=dis) t2-=2*d[dis]; //同上
if(t1>t2)
tr[rt].max_id=tr[rt<<1].max_id;
else tr[rt].max_id=tr[rt<<1|1].max_id;
}
void build(int rt,int l,int r)
{
tr[rt].l=l; tr[rt].r=r;
if(l==r)
{
tr[rt].max_id=l;
return;
}
int mid=l+r>>1;
build(rt<<1,l,mid);
build(rt<<1|1,mid+1,r);
push_up(rt);
}
void update_01(int rt,int l,int r) //update函数1,将选中的点的贡献修改为0
{
if(l==tr[rt].l&&r==tr[rt].r)
{
a[l]=0;
return;
}
int mid=tr[rt].l+tr[rt].r>>1;
if(mid<l) update_01(rt<<1|1,l,r);
else if(mid>=r) update_01(rt<<1,l,r);
else
{
update_01(rt<<1,l,mid);
update_01(rt<<1|1,mid+1,r);
}
push_up(rt);
}
void update_02(int rt,int l,int r) //update函数2,将[1,dis-1]内所有点减去距离的贡献
{
if(l==tr[rt].l&&r==tr[rt].r)
{
a[l]-=2*d[l];
return;
}
int mid=tr[rt].l+tr[rt].r>>1;
if(mid<l) update_02(rt<<1|1,l,r);
else if(mid>=r) update_02(rt<<1,l,r);
else
{
update_02(rt<<1,l,mid);
update_02(rt<<1|1,mid+1,r);
}
push_up(rt);
}
void query(int rt,int l,int r,int &ma)
{
if(l<=tr[rt].l&&tr[rt].r<=r)
{
if(a[tr[rt].max_id]>a[ma])
ma=tr[rt].max_id;
return;
}
if(tr[rt].l==tr[rt].r)
return;
int mid=tr[rt].l+tr[rt].r>>1;
if(mid<l) query(rt<<1|1,l,r,ma);
else if(mid>=r) query(rt<<1,l,r,ma);
else
{
query(rt<<1,l,mid,ma);
query(rt<<1|1,mid+1,r,ma);
}
}
inline void read(int &ret)
{
char c;
while((c=getchar())&&(c>'9'||c<'0'));
ret=0;
while(c>='0'&&c<='9') ret=ret*10+c-'0', c=getchar();
}
inline void out(int x)
{
if(x>9) out(x/10);
putchar(x%10+'0');
}
int main()
{
int n;
read(n);
for(int i=1;i<=n;++i)
read(d[i]);
for(int i=1;i<=n;++i)
{
read(a[i]);
a[i]+=2*d[i];
}
d[0]=0; dis=0; a[0]=0; //初始化这三个数,使操作更方便
build(1,1,n);
int sum=0;
for(int i=1;i<=n;++i)
{
int ma=0;
query(1,1,n,ma);
sum+=a[ma];
update_01(1,ma,ma);
if(ma>dis) //选中的点大于dis,更新dis
{
int temp=dis;
dis=ma;
for(int j=ma-1;j>temp;--j)
update_02(1,j,j);
sum-=2*d[temp]; //记得此时要减去2*d[temp]
}
out(sum);
putchar('\n');
}
return 0;
}
小结:有时候虽然是单点更新,但因为更新次数最多是某个常数,所以就不用担心超时的问题。遇到需要频繁单点更新的问题,也可以往这个角度思考。