洛谷 P2023 [AHOI2009] 维护序列（线段树）

[AHOI2009] 维护序列

题目背景

老师交给小可可一个维护数列的任务，现在小可可希望你来帮他完成。

题目描述

有一个长为 $n$ 的数列 $\{a_n\}$，有如下三种操作形式：

1. 格式 1 t g c，表示把所有满足 $t\le i\le g$ 的 $a_i$ 改为 $a_i\times c$ ;
2. 格式 2 t g c 表示把所有满足 $t\le i\le g$ 的 $a_i$ 改为 $a_i+c$ ;
3. 格式 3 t g 询问所有满足 $t\le i\le g$ 的 $a_i$ 的和，由于答案可能很大，你只需输出这个数模 $p$ 的值。

输入格式

第一行两个整数 $n$ 和 $p$。

第二行含有 $n$ 个非负整数，表示数列 $\{a_i\}$ 。

第三行有一个整数 $m$，表示操作总数。

从第四行开始每行描述一个操作，同一行相邻两数之间用一个空格隔开，每行开头和末尾没有多余空格。

输出格式

对每个操作 3，按照它在输入中出现的顺序，依次输出一行一个整数表示询问结果。

样例 #1

样例输入 #1

7 43
1 2 3 4 5 6 7
5
1 2 5 5
3 2 4
2 3 7 9
3 1 3
3 4 7

样例输出 #1

2
35
8

提示

样例输入输出 1 解释

• 初始时数列为 $\{1,2,3,4,5,6,7\}$。
• 经过第 $1$ 次操作后，数列为 $\{1,10,15,20,25,6,7\}$。
• 对第 $2$ 次操作，和为 $10+15+20=45$，模 $43$ 的结果是 $2$。
• 经过第 $3$ 次操作后，数列为 $\{1,10,24,29,34,15,16\}$。
• 对第 $4$ 次操作，和为 $1+10+24=35$，模 $43$ 的结果是 $35$。
• 对第 $5$ 次操作，和为 $29+34+15+16=94$，模 $43$ 的结果是$8$。

数据规模与约定

测试数据规模如下表所示：

数据点编号	1	2	3	4	5	6	7	8	9,10
$n=$	$10$	$1000$	$1000$	$10000$	$60000$	$70000$	$80000$	$90000$	$100000$
$m=$	$10$	$1000$	$1000$	$10000$	$60000$	$70000$	$80000$	$90000$	$100000$

对于全部的测试点，保证 $0\le p,a_i,c\le 10^9$，$1\le t\le g\le n$。

1、 因为是做区间修改，所以线段树的节点要加上延迟标记，
	add 表示加法，mul 表示乘法
2、 每次处理节点p 的延迟标记，先处理乘法，再处理加法。
	假如节点p 的加法标记 add != 0, 此时，
	节点p又被打上 乘法标记 mul(假如数值是k), 先 改变mul, mul *= k
	那么， add 需要乘上 k, 也就是 add *= k;
	
	相反， 节点p 的加法标记 mul != 1, 此时，
	节点p又被打上 加法标记 add(假如数值是k),  仅仅改变 add即可, add += k
	乘法标记不需要改变。
3、同理，节点p 的延迟标记向其左右孩子传递时候，传递乘法标记 mul时候，
	要把其孩子节点的加法标记 add 也乘上这个数。

#include 
#define lc p<<1
#define rc p<<1|1
typedef long long ll;
using namespace std;
const int MaxN = 100010;
int n;
ll w[MaxN], mod;

struct node
{
	int l, r;
	ll sum, add, mul;
}tr[MaxN * 4];

void pushup(int p)
{
	tr[p].sum = (tr[lc].sum + tr[rc].sum) % mod;
}

void pushdown(int p)	//向下更新
{	// 先处理乘法，再处理加法
	tr[p].mul %= mod;
	if(tr[p].mul != 1)
	{
		tr[lc].sum = tr[lc].sum * tr[p].mul % mod;
		tr[rc].sum = tr[rc].sum * tr[p].mul % mod;
		tr[lc].add = tr[lc].add * tr[p].mul % mod;
		tr[rc].add = tr[rc].add * tr[p].mul % mod;
		tr[lc].mul = tr[lc].mul * tr[p].mul % mod;
		tr[rc].mul = tr[rc].mul * tr[p].mul % mod;
		tr[p].mul = 1;
	}
	tr[p].add %= mod;
	if(tr[p].add != 0)
	{
		ll ld = tr[lc].r - tr[lc].l + 1;
		ll rd = tr[rc].r - tr[rc].l + 1;
		tr[lc].sum = (tr[lc].sum + ld * tr[p].add) % mod;
		tr[rc].sum = (tr[rc].sum + rd * tr[p].add) % mod;
		tr[lc].add = (tr[lc].add + tr[p].add) % mod;
		tr[rc].add = (tr[rc].add + tr[p].add) % mod;
		tr[p].add = 0;
	}
}

void build(int p, int l, int r)
{
	tr[p].l = l, tr[p].r = r, tr[p].sum = w[l] % mod;
	tr[p].add = 0, tr[p].mul = 1;
	if(l == r)
		return;	// 叶子节点返回
	int m = (l + r) >> 1 ;
	build(lc, l, m);
	build(rc, m + 1, r);
	pushup(p);
}


// 在区间 [x, y] 每个点, flag = 1 就增加 k值； flag = 0, 就乘以 k值
void update(int p, int x, int y, ll k, int flag)
{
	if(x <= tr[p].l && tr[p].r <= y)	// 覆盖则修改
	{
		if(flag)
		{
			tr[p].sum = (tr[p].sum + k * (tr[p].r - tr[p].l + 1)) % mod;
			tr[p].add = (tr[p].add + k) % mod;
		}else{
			tr[p].sum = tr[p].sum * k % mod;
			tr[p].mul = tr[p].mul * k % mod;
			tr[p].add = tr[p].add * k % mod;
		}
		return;
	}
	pushdown(p);
	int m = (tr[p].l + tr[p].r) >> 1;
	if(x <= m)
	{
		update(lc, x, y, k, flag);	
	}
	if(y > m)
	{
		update(rc, x, y, k, flag);	
	}
	pushup(p);
}

// 查询区间 [x, y] 的总和
ll query(int p, int x, int y)
{
	if(x <= tr[p].l && tr[p].r <= y)
	{
		return tr[p].sum % mod;		
	}
	int m = (tr[p].l + tr[p].r) >> 1;
	pushdown(p);
	ll sum = 0;
	if(x <= m)
	{
		sum += query(lc, x, y);
		sum %= mod;
	}
	if(y > m)
	{	
		sum += query(rc, x, y);
		sum %= mod;
	}
	return sum % mod;
}

int main()
{
	scanf("%d%lld", &n, &mod);
	for(int i = 1; i <= n; ++i)
		scanf("%lld", &w[i]);
	build(1, 1, n);
	int k, op, x, y;
	ll z;
	scanf("%d", &k);
	while(k--)
	{
		scanf("%d%d%d", &op, &x, &y);
		if(3 == op)
		{
			printf("%lld\n", query(1, x, y));
		}else if(1 == op){	//乘以 z
			scanf("%lld", &z);
			if(z % mod != 1)
				update(1, x, y, z % mod, 0);
		}else{				//加上z
			scanf("%lld", &z);	
			if(z % mod != 0)
				update(1, x, y, z % mod, 1);
		}
	}
	return 0;
}