hdu 3954 Level up（成段更新）

题意：有N个英雄，每个英雄的初始等级为1，初始经验为0，有K个等级，QW个操作。接下来一行中有K-1个数值，代表升到等级2，等级3……所要达到的经验。接下来的QW行里，每行是一个操作，操作有两类，（1）"l r e"，代表区间[l,r]里的每个英雄将得到e乘以他的等级的经验。（2）"l r"，表示查询区间[l,r]里经验最大值。

        除了可以分成k棵线段树做之外，也可以合成一棵线段树做。

        合成一棵段树做要解决这样的问题：每次得到经验的时候，区间内所有的英雄得到的“经验”应该是没有区别的，我们在线段树的结点里添加一个域，表示达到下一级需要多少“经验”，这里的“经验”是下一级别的经验减去当前英雄的经验再除以当前英雄的等级的，这样，我们就消除了英雄们得到的经验的差别。另外，还有这样的结论，等级最高的，其得到经验值也一定最多，有了这个结论，就可以去成段地更新了，查询简单地在线段树结点中保存一个最大值就可以了。

       之所以是成段更新而放在其他分类里，一方面是确实有其他做法，一方面也是遵循了NotOnlySuccess大神的分类。

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

#define LL(x) (x<<1)
#define RR(x) (x<<1|1)
#define MID(a,b) (a+((b-a)>>1))
#define INF (1<<30)
const int N=10000+5;
typedef long long LL;

struct node
{
	int lft,rht;
	LL level,mx,flag,need;
	int mid(){return MID(lft,rht);}
	void init(){level=1;mx=0;flag=0;}
	void fun(LL valu)
	{
		mx+=level*valu;
		need-=valu;
		flag+=valu;
	}
};

int n,m,k;
LL ned[12];

struct Segtree
{
	node tree[N*4];
	void down(int ind)
	{
		if(tree[ind].flag)
		{
			tree[LL(ind)].fun(tree[ind].flag);
			tree[RR(ind)].fun(tree[ind].flag);
			tree[ind].flag=0;
		}
	}
	void up(int ind)
	{
		tree[ind].mx=max(tree[LL(ind)].mx,tree[RR(ind)].mx);
		tree[ind].level=max(tree[LL(ind)].level,tree[RR(ind)].level);
		tree[ind].need=min(tree[LL(ind)].need,tree[RR(ind)].need);
	}
	void build(int lft,int rht,int ind)
	{
		tree[ind].lft=lft;	tree[ind].rht=rht;
		tree[ind].init(); 	tree[ind].need=ned[2];
		if(lft!=rht)
		{
			int mid=tree[ind].mid();
			build(lft,mid,LL(ind));
			build(mid+1,rht,RR(ind));
		}
	}
	void updata(int st,int ed,int ind,int valu)
	{
		int lft=tree[ind].lft,rht=tree[ind].rht;
		if(st<=lft&&rht<=ed)
		{
			if(valu>=tree[ind].need)
			{
				if(lft==rht)
				{
					LL &now=tree[ind].level;
					tree[ind].mx+=now*valu;
					while(tree[ind].mx>=ned[now+1]) now++;
					LL tmp=ned[now+1]-tree[ind].mx;
					tree[ind].need=tmp/now+(tmp%now!=0);
				}
				else 
				{
					down(ind);
					int mid=tree[ind].mid();
					if(st<=mid) updata(st,ed,LL(ind),valu);
					if(ed> mid) updata(st,ed,RR(ind),valu);
					up(ind);
				}
			}
			else 
			{
				tree[ind].fun(valu);
			}
		}
		else 
		{
			down(ind);
			int mid=tree[ind].mid();
			if(st<=mid) updata(st,ed,LL(ind),valu);
			if(ed> mid) updata(st,ed,RR(ind),valu);
			up(ind);
		}
	}
	LL query(int st,int ed,int ind)
	{
		int lft=tree[ind].lft,rht=tree[ind].rht;
		if(st<=lft&&rht<=ed) return tree[ind].mx;
		else 
		{
			down(ind);
			int mid=tree[ind].mid();
			LL mx1=0,mx2=0;
			if(st<=mid) mx1=query(st,ed,LL(ind));
			if(ed> mid) mx2=query(st,ed,RR(ind));
			up(ind);
			return max(mx1,mx2);
		}
	}
}seg;
int main()
{
	int t,t_cnt=0;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d%d%d",&n,&k,&m);
		ned[1]=0; ned[k+1]=((LL)1<<60);
		for(int i=2;i<=k;i++) scanf("%I64d",&ned[i]);

		printf("Case %d:\n",++t_cnt);
		seg.build(1,n,1);
		while(m--)
		{
			char cmd[5];
			int a,b,c;
			scanf("%s",cmd);
			if(cmd[0]=='W')
			{
				scanf("%d%d%d",&a,&b,&c);
				seg.updata(a,b,1,c);
			}
			else 
			{
				scanf("%d%d",&a,&b);
				printf("%I64d\n",seg.query(a,b,1));
			}
		}
		puts("");
	}
	return 0;
}