洛谷P2672 推销员（线段树+贪心）

分析样例可以知道：
当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;
}

小结：有时候虽然是单点更新，但因为更新次数最多是某个常数，所以就不用担心超时的问题。遇到需要频繁单点更新的问题，也可以往这个角度思考。