洛谷P3373 【模板】线段树 2

题目描述

如题，已知一个数列，你需要进行下面三种操作：

1.将某区间每一个数乘上x

2.将某区间每一个数加上x

3.求出某区间每一个数的和

输入输出格式

输入格式：

 

第一行包含三个整数N、M、P，分别表示该数列数字的个数、操作的总个数和模数。

第二行包含N个用空格分隔的整数，其中第i个数字表示数列第i项的初始值。

接下来M行每行包含3或4个整数，表示一个操作，具体如下：

操作1： 格式：1 x y k 含义：将区间[x,y]内每个数乘上k

操作2： 格式：2 x y k 含义：将区间[x,y]内每个数加上k

操作3： 格式：3 x y 含义：输出区间[x,y]内每个数的和对P取模所得的结果

 

输出格式：

 

输出包含若干行整数，即为所有操作3的结果。

 

输入输出样例

输入样例#1： 

5 5 38
1 5 4 2 3
2 1 4 1
3 2 5
1 2 4 2
2 3 5 5
3 1 4

输出样例#1： 

17
2

说明

时空限制：1000ms,128M

数据规模：

对于30%的数据：N<=8，M<=10

对于70%的数据：N<=1000，M<=10000

对于100%的数据：N<=100000，M<=100000

（数据已经过加强^_^）

解题思路

这题主要问题是如何维护lazy，因为有两个操作，+和*，所以用两个lazy标记，lazy1标记+，初始化为0，lazy2标记*，初始化为1。如果一个节点的lazy1不等于0或lazy2不等于1，那么就说明这个节点的子树都没有更新，这个时候就把标记向下传，并更新左右子树。那么问题来了，谁先谁后呢。先乘法后加法。

因为（a * lazy2）+ lazy1，当如果是乘法操作，乘以k2（区间内每个数要乘以的值），则变为((a * lazy2) + lazy1)*k2 = (a * (lazy2*k2)) + lazy1*k2，所以在更新lazy1的时候不能直接加上（r-l）* k1（区间内每个数要加上的值），要先乘以k2再加上k1。

lazy下传函数如下

void down(int k)
{
	tree[k * 2].w = (tree[k * 2].w * tree[k].lazy2 % p + (tree[k*2].r - tree[k*2].l + 1) * tree[k].lazy1 % p)%p;
	tree[k*2+1].w = (tree[k * 2 + 1].w * tree[k].lazy2%p + (tree[k*2+1].r - tree[k*2+1].l + 1)*tree[k].lazy1%p)%p;
	
	tree[k * 2].lazy2 = (tree[k * 2].lazy2*tree[k].lazy2) % p;
	tree[k * 2].lazy1 = (tree[k * 2].lazy1 * tree[k].lazy2 + tree[k].lazy1) % p;
	tree[k * 2 + 1].lazy2 = (tree[k * 2 + 1].lazy2 * tree[k].lazy2) % p;
	tree[k * 2 + 1].lazy1 = (tree[k * 2 + 1].lazy1 * tree[k].lazy2 + tree[k].lazy1) % p;
	
	tree[k].lazy1 = 0;
	tree[k].lazy2 = 1;
}

完整代码如下

#include <iostream>
#include <cstdio>
using namespace std;
typedef long long ll;
int n, m, p;
struct Tree{
	ll l, r, w, lazy1, lazy2;    //有lazy说明下一层全没有更新 
};
Tree tree[400005];
void init(int k, int l, int r)   //初始化 
{
	tree[k].l = l;
	tree[k].r = r;
	if(tree[k].l == tree[k].r){
		scanf("%lld", &tree[k].w);
		return;
	}
	init(k * 2, l, (l + r) / 2);
	init(k * 2 + 1, (l + r) / 2 + 1, r);
	tree[k].w = (tree[k * 2].w + tree[k * 2 + 1].w) % p;
}
void down(int k)
{
	tree[k * 2].w = (tree[k * 2].w * tree[k].lazy2 % p + (tree[k*2].r - tree[k*2].l + 1) * tree[k].lazy1 % p)%p;
	tree[k*2+1].w = (tree[k * 2 + 1].w * tree[k].lazy2%p + (tree[k*2+1].r - tree[k*2+1].l + 1)*tree[k].lazy1%p)%p;
	
	tree[k * 2].lazy2 = (tree[k * 2].lazy2*tree[k].lazy2) % p;
	tree[k * 2].lazy1 = (tree[k * 2].lazy1 * tree[k].lazy2 + tree[k].lazy1) % p;
	tree[k * 2 + 1].lazy2 = (tree[k * 2 + 1].lazy2 * tree[k].lazy2) % p;
	tree[k * 2 + 1].lazy1 = (tree[k * 2 + 1].lazy1 * tree[k].lazy2 + tree[k].lazy1) % p;
	
	tree[k].lazy1 = 0;
	tree[k].lazy2 = 1;
}
void update(int k, int l, int r, ll z, int ins)   //更新节点 
{
	if(tree[k].l >= l && tree[k].r <= r){
		if(ins == 1){
			tree[k].w = (tree[k].w * z) % p;
			tree[k].lazy2 = (tree[k].lazy2 * z) % p;
			tree[k].lazy1 = (tree[k].lazy1 * z) % p; 
		}
		else if(ins == 2){
			tree[k].w = (tree[k].w + (tree[k].r - tree[k].l + 1) * z) % p;
			tree[k].lazy1 += z % p;
		}
		return;
	}
	if(tree[k].lazy1 || tree[k].lazy2 != 1)
		down(k);
	int mid = (tree[k].l + tree[k].r) / 2;
	if(l <= mid)
		update(2 * k, l, r, z, ins);
	if(r >= mid + 1)
		update(2 * k + 1, l, r, z, ins);
	tree[k].w = (tree[k*2].w + tree[k*2+1].w) % p;
}
ll query(int k, int l, int r)   //查询区间 
{
	if(tree[k].l >= l && tree[k].r <= r){
		return tree[k].w;
	}
	if(tree[k].lazy1 || tree[k].lazy2 != 1)
		down(k);
	int mid = (tree[k].l + tree[k].r) / 2;
	ll left = 0;
	ll right = 0;
	if(l <= mid)
		left = query(2 * k, l, r);
	if(r > mid)
		right = query(2*k+1, l, r);
	return (left % p + right % p) % p;
}
int main()
{	
	while(cin >> n >> m >> p){
		for(int i = 0; i <= 4 * n; i ++){
			tree[i].lazy1 = 0;
			tree[i].lazy2 = 1;
		}		
		init(1, 1, n);
		for(int i = 0; i < m; i ++){
			int ins;
			scanf("%d", &ins);
			if(ins == 1){
				int x, y;
				ll k;
				scanf("%d%d%lld", &x, &y, &k);
				update(1, x, y, k, 1);
			}
			else if(ins == 2){
				int x, y;
				ll k;
				scanf("%d%d%lld", &x, &y, &k);
				update(1, x, y, k, 2);
			}
			else {
				int x, y;
				scanf("%d%d", &x, &y);
				printf("%lld\n", query(1, x, y) % p);
			}
		}
	}
	return 0;
}