(模板）线段树（区间双重更新，区间求和）

题目可参见洛谷P3373

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

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

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

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

首先先说明本题的思路。题目要求有三种操作，两种是不同的在线修改，还有一种是在查询取模后的结果。而这两种操作又是区间乘法和区间加法，我们可以惊喜的发现这两种操作对于取模运算来说都是自由的！但是面对非常大的数据，我们必须思考怎么样用线段树优雅的跑过这道题目。

面对这两种操作，可以联想到线段树的一个非常好的功能就是lazytag，只计算出确实需要访问的区间的真实值，其他的保存在lazytag里面，这样可以近似O(NlogN)的运行起来。在尝试着写了只有一个lazetag的程序之后我们发现一个lazytag是不能够解决问题的，那就上两个，分别表示乘法意义上的lazytag和加法意义上的lazytag。紧接着想到pushdown操作之后我们又发现必须在向下传递lazytag的时候人为地为这两个lazytag规定一个先后顺序，排列组合一下只有两种情况：

①加法优先，即规定好segtree[root*2].value=((segtree[root*2].value+segtree[root].add)*segtree[root].mul)%p，问题是这样的话非常不容易进行更新操作，假如改变一下add的数值，mul也要联动变成奇奇怪怪的分数小数损失精度，我们内心是很拒绝的；

②乘法优先，即规定好segtree[root*2].value=(segtree[root*2].value*segtree[root].mul+segtree[root].add*(本区间长度))%p，这样的话假如改变add的数值就只改变add，改变mul的时候把add也对应的乘一下就可以了，没有精度损失，看起来很不错。

一定要注意顺序的问题！！

代码：

#include<cstdio>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;
const int maxn = 100010;
int array1[maxn], n, m, p;
struct node1 {//sum是区间值，add是加的记号，另一个是乘
ll sum, add, mul;
}Node[maxn<<2];
void pushup(int node)
{
Node[node].sum = (Node[node << 1].sum + Node[node << 1 | 1].sum)%p;
}
void buildtree(int node, int begin, int end)
{
Node[node].add = 0; Node[node].mul = 1;
if (begin == end) {
Node[node].sum = array1[begin];
return;
}
int m = (begin + end) >> 1;
buildtree(node * 2, begin, m);
buildtree(node * 2 + 1, m + 1, end);
pushup(node);
}
void pushdown(int node,int process, int begin, int end)
{
if (process == 1) {
if (Node[node].mul != 1) {//process是1代表乘，是0代表加（下同）
Node[node << 1].mul = Node[node].mul*Node[node << 1].mul%p;
Node[node << 1 | 1].mul = Node[node].mul*Node[node << 1 | 1].mul%p;
Node[node << 1].add = Node[node].mul*Node[node << 1].add%p;
Node[node << 1 | 1].add = Node[node].mul*Node[node << 1 | 1].add%p;
Node[node << 1].sum = Node[node].mul*Node[node << 1].sum%p;
Node[node << 1 | 1].sum = Node[node].mul*Node[node << 1 | 1].sum%p;
Node[node].mul = 1;
}
}
else {
if (Node[node].add) {
int m = (begin + end) >> 1;
Node[node << 1].add = (Node[node].add + Node[node << 1].add) % p;
Node[node << 1 | 1].add = (Node[node << 1 | 1].add + Node[node].add) % p;
Node[node << 1].sum = (Node[node << 1].sum + (m - begin + 1)*Node[node].add%p) % p;
Node[node << 1 | 1].sum = (Node[node << 1 | 1].sum + (end - m)*Node[node].add%p) % p;
Node[node].add = 0;
}
}
}
ll query(int node, int begin, int end, int left, int right)
{
if (left <= begin&&right >= end) {
return Node[node].sum%p;
}
pushdown(node, 1, begin, end);//（先乘后加）
pushdown(node, 0, begin, end);
ll ans = 0;
int m = (begin + end) >> 1;
if (left <= m)
ans = (ans+query(node * 2, begin, m, left, right))%p;
if (right > m)
ans = (ans + query(node * 2 + 1, m + 1, end, left, right))%p;
return ans;
}
void update(int node, int process, int add, int begin, int end, int left, int right)
{
if (left <= begin&&right >= end) {
if (process == 1) {
Node[node].mul = Node[node].mul*add%p;
Node[node].add = Node[node].add*add%p;
Node[node].sum = Node[node].sum*add%p;
}
else {
Node[node].sum = (Node[node].sum + add*(end-begin+1)%p) % p;
Node[node].add = (Node[node].add + add) % p;

}
return;
}
int m = (begin + end) >> 1;
pushdown(node, 1, begin, end);
pushdown(node, 0, begin, end);
if (left <= m)
update(node * 2, process, add, begin, m, left, right);
if (right > m)
update(node * 2 + 1, process, add, m + 1, end, left, right);
pushup(node);
}
int main(void)
{
cin >> n >> m >> p;

for (int i = 1; i <= n; i++) {
scanf("%d", &array1[i]);
}
buildtree(1, 1, n);
for (int i = 1; i <= m; i++) {
int a, b, c, d;
scanf("%d", &a);
if (a == 1) {
scanf("%d %d %d", &b, &c, &d);
update(1, 1, d, 1, n, b, c);
}
else if (a == 2) {
scanf("%d %d %d", &b, &c, &d);
update(1, 0, d, 1, n, b, c);
}
else {
scanf("%d %d", &b, &c);
printf("%lld\n", query(1, 1, n, b, c));
}
}

return 0;
}