线段树（区间修改，区间查询）

题目链接：区间修改，区间查询

build：基于后序遍历和区间二分的思想，递归建树

change：

1. r < s or l > t，当前区间与待修改区间没有交集，直接return
2. s <= l and r <= t，当前区间为待修改区间的子区间，更新区间权值和懒标记
3. 当前区间与待修改区间有部分交集，则将懒标记下传，并递归查找子区间，同时维护线段树

query：

1. r < s or l > t，当前区间与查询区间没有交集，返回0
2. s <= l and r <= t，当前区间为查询区间的子区间，返回当前区间权值
3. 当前区间与查询区间有部分交集，则将懒标记下传，并递归求子区间权值之和

#include <bits/stdc++.h>
#define int long long
using namespace std;
int d[4000020], a[1000005], lazy[4000020];
void build(int p, int l, int r) {
    if (l == r) {
        d[p] = a[l];
        return;
    }
    int m = l + r >> 1;
    build(p << 1, l, m);
    build(p << 1 | 1, m + 1, r);
    d[p] = d[p << 1] + d[p << 1 | 1];
}
void push_down(int p, int l, int r, int m) {
    d[p << 1] += lazy[p] * (m - l + 1);
    d[p << 1 | 1] += lazy[p] * (r - m);
    lazy[p << 1] += lazy[p];
    lazy[p << 1 | 1] += lazy[p];
    lazy[p] = 0;
}
void change(int p, int l, int r, int s, int t, int v) {
    if (r < s || l > t) {
        return;
    } else if (s <= l && r <= t) {
        d[p] += (r - l + 1) * v;
        lazy[p] += v;
        return;
    } else {
        int m = l + r >> 1;
        push_down(p, l, r, m);
        change(p << 1, l, m, s, t, v);
        change(p << 1 | 1, m + 1, r, s, t, v);
        d[p] = d[p << 1] + d[p << 1 | 1];
    }
}
int query(int p, int l, int r, int s, int t) {
    if (r < s || l > t) {
        return 0;
    } else if (s <= l && r <= t) {
        return d[p];
    } else {
        int m = l + r >> 1;
        push_down(p, l, r, m);
        return query(p << 1, l, m, s, t) + query(p << 1 | 1, m + 1, r, s, t);
    }
}
signed main() {
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    build(1, 0, n - 1);
    while (m--) {
        int op, l, r, v;
        cin >> op;
        if (op == 1) {
            cin >> l >> r >> v;
            change(1, 1, n, l, r, v);
        } else {
            cin >> l >> r;
            cout << query(1, 1, n, l, r) << endl;
        }
    }
    return 0;
}

区间乘法：奇妙序列

在上述的线段树模板上加一个乘法的mul懒标记即可

进行区间乘法操作时，加法的lazy标记记得也要乘上乘数，我因为这个调了一天QAQ

class Fancy:
 
    def __init__(self):
        self.d = [0] * 400020
        self.lazy = [0] * 400020
        self.mul = [1] * 400020
        self.n = 0
        self.mod = 10 ** 9 + 7
 
    def push_down(self, l, r, p):
        m = l + r >> 1
        self.d[p << 1] *= self.mul[p]
        self.d[p << 1 | 1] *= self.mul[p]
        self.mul[p << 1] *= self.mul[p]
        self.mul[p << 1 | 1] *= self.mul[p]
        self.lazy[p << 1] *= self.mul[p]
        self.lazy[p << 1 | 1] *= self.mul[p]
        self.mul[p] = 1
        self.d[p << 1] += self.lazy[p] * (m - l + 1)
        self.d[p << 1 | 1] += self.lazy[p] * (r - m)
        self.lazy[p << 1] += self.lazy[p]
        self.lazy[p << 1 | 1] += self.lazy[p]
        self.lazy[p] = 0
        self.d[p << 1] %= self.mod
        self.d[p << 1 | 1] %= self.mod
        self.mul[p << 1] %= self.mod
        self.mul[p << 1 | 1] %= self.mod
        self.lazy[p << 1] %= self.mod
        self.lazy[p << 1 | 1] %= self.mod
 
    def change(self, p, l, r, s, t, v, mu):
        if r < s or l > t:
            return
        elif s <= l and r <= t:
            self.d[p] += (r - l + 1) * v;
            self.lazy[p] += v
            self.d[p] *= mu;
            self.mul[p] *= mu
            self.lazy[p] *= mu;
            self.d[p] %= self.mod
            self.lazy[p] %= self.mod
            self.mul[p] %= self.mod
            return
        else:
            m = l + r >> 1
            if self.lazy[p] != 0 or self.mul[p] != 1:
                self.push_down(l, r, p)
            self.change(p << 1, l, m, s, t, v, mu)
            self.change(p << 1 | 1, m + 1, r, s, t, v, mu)
            self.d[p] = (self.d[p << 1] + self.d[p << 1 | 1]) % self.mod
    
    def query(self, p, l, r, s, t):
        if r < s or l > t:
            return 0
        elif s <= l and r <= t:
            return self.d[p] % self.mod
        else:
            m = l + r >> 1
            if self.lazy[p] != 0 or self.mul[p] != 1:
                self.push_down(l, r, p)
            return (self.query(p << 1, l, m, s, t) + self.query(p << 1 | 1, m + 1, r, s, t)) % self.mod
 
    def append(self, val: int) -> None:
        self.n += 1
        self.change(1, 1, 100000, self.n, self.n, val, 1)
 
    def addAll(self, inc: int) -> None:
        self.change(1, 1, 100000, 1, self.n, inc, 1)
 
    def multAll(self, m: int) -> None:
        self.change(1, 1, 100000, 1, self.n, 0, m)
 
    def getIndex(self, idx: int) -> int:
        if idx + 1 > self.n:
            return -1
        return self.query(1, 1, 100000, idx + 1, idx + 1) % self.mod