E

题意：
给你一个数组，然后两种操作，一种是让l到r的数字变成k,k+1,k+2,…k+r-l。一种操作时查询l到r的值。

思考：
很明显的线段树了，感觉一看就和以前做过的一题几乎一样无聊的数列。那个题就是让你每个区间会加上一个等差数列，这个题是覆盖变成一个等差数列。而且那个题求的是单点值，所以维护一个差分，求的时候求1到x的求和就行了，对差分求前缀和就是单点的值。这道题的是覆盖性的，所以就用懒标记一下就行，维护的时候，维护的是一个区间的和。对于修改的时候，看看首项该是多少，区间和就是等差序列的公式。感觉这题对线段树的理解还是挺好的。

代码：

本题代码：

struct node{
	int L,R;
	int sum;
	int laz;
}t[4*N];

int T,n,m,k;
int va[N];

void pushdown(int node)
{
	if(t[node].laz)
	{
		t[node_l].laz = t[node].laz;
		t[node_l].sum = (t[node_l].R-t[node_l].L+1)*(t[node_l].laz+t[node_l].laz+t[node_l].R-t[node_l].L)/2;
		t[node_r].laz = t[node].laz+t[node_l].R-t[node_l].L+1; //右边的首项就是这样的对吧左边的加上左子树的个数
		t[node_r].sum = (t[node_r].R-t[node_r].L+1)*(t[node_r].laz+t[node_r].laz+t[node_r].R-t[node_r].L)/2;
		t[node].laz = 0;
	}
}

void build(int node,int l,int r)
{
	t[node].L = l,t[node].R = r;
	if(l==r)
	{
		t[node].sum = va[l];
		return ;
	}
	int mid = l+r>>1;
	build(node_l,l,mid);build(node_r,mid+1,r);
	t[node].sum = t[node_l].sum+t[node_r].sum;
}

void update(int node,int l,int r,int value)
{
	if(t[node].L>=l&&t[node].R<=r)
	{
		t[node].laz = t[node].L-l+value;
		t[node].sum = (t[node].R-t[node].L+1)*(t[node].laz+t[node].laz+t[node].R-t[node].L)/2;
		return ;
	}
	pushdown(node); //如果这个区间覆盖止node这一个节点，那么node节点的情况要先分配下去。
	int mid = (t[node].L+t[node].R)>>1;
	if(l<=mid) update(node_l,l,r,value); //更新左边，更新是可以重复更新的，所以左右如果有交叉也没事。
	if(r>mid) update(node_r,l,r,value);
	t[node].sum = t[node_l].sum+t[node_r].sum;
}

int query(int node,int l,int r)
{
	if(t[node].L>=l&&t[node].R<=r) return t[node].sum;
	pushdown(node);
	int mid = (t[node].L+t[node].R)>>1;
	if(r<=mid) return query(node_l,l,r); //查询就不一样了，该查询多少就是多少。
	else if(l>mid) return query(node_r,l,r);
	else return query(node_l,l,mid)+query(node_r,mid+1,r); //看好细节。
}

signed main()
{
	IOS;
	cin>>n>>m;
	for(int i=1;i<=n;i++) cin>>va[i];
	build(1,1,n);
	while(m--)
	{
		int op,a,b,c;
		cin>>op;
		if(op==1)
		{
			cin>>a>>b>>c;
			update(1,a,b,c);
		}
		else
		{
			cin>>a>>b;
			cout<<query(1,a,b)<<"\n";
		}
	}
	return 0;
}

无聊的数列代码：
struct Node{
	int L,R;
	ll laz;
	ll sum;
}t[4*N];

int n,m;
int va[N];

void down(int node)
{
	int laz = t[node].laz;
	t[node_l].laz += laz;
	t[node_l].sum += (t[node_l].R-t[node_l].L+1)*laz;
	t[node_r].laz += laz;
	t[node_r].sum += (t[node_r].R-t[node_r].L+1)*laz;
	t[node].laz = 0;	
}

void build(int node,int l,int r)
{
	t[node].L = l,t[node].R = r;
	if(l==r)
	{
		t[node].sum = 0;
		return ;
	}
	int mid = (l+r)>>1;
	build(node_l,l,mid);
	build(node_r,mid+1,r);
	t[node].sum = t[node_l].sum+t[node_r].sum;
}

void update(int node,int l,int r,int value)
{
	if(t[node].L>r||t[node].R<l) return ;
	if(t[node].L>=l&&t[node].R<=r)
	{
		t[node].sum += (t[node].R-t[node].L+1)*value;
		t[node].laz += value;						 
		return ;
	}
	down(node);
	int mid = (l+r)>>1;
	update(node_l,l,r,value);
	update(node_r,l,r,value);
	t[node].sum = t[node_l].sum+t[node_r].sum;
}

int query(int node,int l,int r)
{
	if(t[node].L>r||t[node].R<l) return 0;
	if(t[node].L>=l&&t[node].R<=r)
	{
		return t[node].sum;
	}
	down(node);
	return query(node_l,l,r)+query(node_r,l,r);
}

signed main()
{
	cin>>n>>m;
	for(int i=1;i<=n;i++) cin>>va[i];
	build(1,1,n);
	for(int i=1;i<=m;i++)
	{
		int op;
		cin>>op;
		if(op==1)
		{
			int a,b,k,d;
			cin>>a>>b>>k>>d;
			update(1,a,a,k);
			if(b>a) update(1,a+1,b,d);
			if(b<n) update(1,b+1,b+1,-k-(b-a)*d);
		}
		else
		{
			int p;
			cin>>p;
			cout<<query(1,1,p)+va[p]<<endl;
		}
	}
	return 0;
}

总结：
多多理解本质，多多思考。