线段树基础题（范围重置、范围增加，维护区间和）

线段树基础题（范围重置、范围增加，维护区间和）

---

题意： 维护区间和，简单区间修改（范围重置与范围增加）。输入 1 为范围重置操作， 2 为范围增加操作， 3 为查询操作。
思路： 线段树维护区间和，两个lazy tag维护线段树。tag1维护范围重置操作，tag2维护范围增加操作。由于有两个懒标记存在，我们在下放懒标记时需考虑懒标记的优先级是并行还是有优先顺序，如在此题中区间重置操作时可以覆盖区间增加操作的，故我们在处理两个操作需谨慎，此题我的处理方法是：

1. 在调用update执行范围重置时，将此范围的范围增加懒标记（tag2）覆盖：

if(op == 1) {		//在进行范围重置时，将此处原有的tag2覆盖，置为0
			tree[p] = k;
			tag1[p] = k;
			tag2[p] = 0;
}

2. 在下传懒标记的时候，若存在范围重置懒标记（tag1），则一同下传范围增加懒标记（tag2），否则只下传tag2。

//传递lazy tag父范围已经改变过，当需要查询或改变子区间范围值时，将父范围的lazy tag下传，并修改子区间范围的值
//在下传tag1时将tag2一同下传，此时的tag2为被tag1覆盖后的tag2
inline void down(int p , int l , int r) {
	int mid = l + r >> 1;
	if(tag1[p] != MIN) {
		tree[ls(p)] = (tag1[p] + tag2[p]) * (mid - l + 1);
		tree[rs(p)] = (tag1[p] + tag2[p]) * (r - mid);
		tag1[ls(p)] = tag1[p];
		tag1[rs(p)] = tag1[p];
		tag2[ls(p)] = tag2[p];		//不要 +=，需要将前面的tag2覆盖掉
		tag2[rs(p)] = tag2[p];
		tag2[p] = 0;
		tag1[p] = MIN;
	}else if(tag2[p]) {
		tree[ls(p)] += tag2[p] * (mid - l + 1);
		tree[rs(p)] += tag2[p] * (r - mid);
		tag2[ls(p)] += tag2[p];
		tag2[rs(p)] += tag2[p];
		tag2[p] = 0;
	}
}

本题无原题链接（若有错误，感谢指正），附手写样例：

输入：
6 8
1 1 4 5 1 4
3 1 6
1 1 3 2
3 1 2
3 2 4
2 3 4 3
3 2 4
1 1 5 0
3 1 6
输出：
16
4
9
15
4

代码：

// LH
#include<bits/stdc++.h>
using namespace std;
//#define int long long
typedef long long ll;
typedef pair<int,int> PII;
typedef pair<ll,ll> PLL;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<PII> VPII;
typedef vector<PLL> VPLL;
//维护区间最大值;范围重置 , 范围增加;lazy tag;
//lazy tag的优先级处理
const int N = 1e6 + 6;
const ll MIN = -1e18;
int ls(int x) {return x << 1;}
int rs(int x) {return x << 1 | 1;}
ll tree[N<<2] , tag1[N<<2] , tag2[N<<2];//tag1维护范围重置，tag2维护范围增加

//信息汇总，在修改了子区间范围的值后导致父范围的值发生改变应该将子范围的信息重新汇总到父范围
inline void up(int p) {tree[p] = tree[ls(p)] + tree[rs(p)];}

//传递lazy tag父范围已经改变过，当需要查询或改变子区间范围值时，将父范围的lazy tag下传，并修改子区间范围的值
//在下传tag1时将tag2一同下传，此时的tag2为被tag1覆盖后的tag2
inline void down(int p , int l , int r) {
	int mid = l + r >> 1;
	if(tag1[p] != MIN) {
		tree[ls(p)] = (tag1[p] + tag2[p]) * (mid - l + 1);
		tree[rs(p)] = (tag1[p] + tag2[p]) * (r - mid);
		tag1[ls(p)] = tag1[p];
		tag1[rs(p)] = tag1[p];
		tag2[ls(p)] = tag2[p];		//不要 +=，需要将前面的tag2覆盖掉
		tag2[rs(p)] = tag2[p];
		tag2[p] = 0;
		tag1[p] = MIN;
	}else if(tag2[p]) {
		tree[ls(p)] += tag2[p] * (mid - l + 1);
		tree[rs(p)] += tag2[p] * (r - mid);
		tag2[ls(p)] += tag2[p];
		tag2[rs(p)] += tag2[p];
		tag2[p] = 0;
	}
}

//建树
inline void build(int l , int r , int p) {
	tag1[p] = MIN;
	if(l == r) {
		cin >> tree[p];
		return;
	}
	int mid = l + r >> 1;
	build(l , mid , ls(p));
	build(mid + 1 , r , rs(p));
	up(p);
}

//查询时若需查询子区间应将lazy tag下传，并根据lazy tag修改子区间范围的值
inline ll query(int l , int r , int p , int lx , int rx) {
	if(lx <= l && r <= rx) {
		return tree[p];
	}
	down(p , l , r);
	int mid = l + r >> 1;
	ll sum = 0;
	if(lx <= mid) sum += query(l , mid , ls(p) , lx , rx);
	if(rx > mid) sum += query(mid+1 , r , rs(p) , lx , rx);
	return sum;
}

//修改，在需要修改子区间范围时，记得下传lazy tag
inline void update(int l , int r , int p , int lx , int rx , int k , int op) {
	if(lx <= l && r <= rx) {
		if(op == 1) {		//在进行范围重置时，将此处原有的tag2覆盖，置为0
			tree[p] = k;
			tag1[p] = k;
			tag2[p] = 0;
		}else {
			tree[p] += k * (r - l + 1);
			tag2[p] += k;
		}
		return;
	}
	down(p , l , r);		//不要忘了下传lazy tag否则可能会导致子范围未正确修改，up函数上传错误信息至父范围
	int mid = l + r >> 1;
	if(lx <= mid) update(l , mid , ls(p) , lx , rx , k , op);
	if(rx > mid) update(mid+1 , r , rs(p) , lx , rx , k , op);
	up(p);
}
void solve(){
	int n , m;
	cin >> n >> m;
	build(1 , n , 1);
	while(m --) {
		int op;
		cin >> op;
		if(op == 1 || op == 2) {
			int x , y , k;
			cin >> x >> y >> k;
			update(1 , n , 1 , x , y , k , op);
		}else {
			int x , y;
			cin >> x >> y;
			cout << query(1 , n , 1 , x , y) << '\n';
		}
	}
}
signed main() {
	std::ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	int t = 1;
	//cin >> t;
	while(t--){
		solve();
	}
	
	return 0;
}