NC19246 数据结构

题目链接

题目

题目描述

qn姐姐最好了~

qn姐姐给你了一个长度为n的序列还有m次操作让你玩，

1 l r 询问区间[l,r]内的元素和

2 l r 询问区间[l,r]内的元素的平方和

3 l r x 将区间[l,r]内的每一个元素都乘上x

4 l r x 将区间[l,r]内的每一个元素都加上x

输入描述

第一行两个数n,m

接下来一行n个数表示初始序列

就下来m行每行第一个数为操作方法opt，

若opt=1或者opt=2，则之后跟着两个数为l,r

若opt=3或者opt=4，则之后跟着三个数为l,r,x

操作意思为题目描述里说的

输出描述

对于每一个操作1,2，输出一行表示答案

示例1

输入

5 6
1 2 3 4 5
1 1 5
2 1 5
3 1 2 1
4 1 3 2
1 1 4
2 2 3

输出

15
55
16
41

备注

对于100%的数据 n=10000,m=200000 (注意是等于号)

保证所有询问的答案在long long 范围内

题解

知识点：线段树，数学。

区间信息需要维护区间长度 \(len\) 、区间和 \(val\) 、区间平方和 \(val2\) ，合并直接加即可。

区间修改需要维护区间加 \(add\) 、区间乘 \(mul\) 。区间和、 区间平方和的修改公式：

\[\begin{aligned}
\sum_{i=l}^{r} (mul \cdot a_i + add) &= mul \cdot \sum_{i=l}^{r} a_i + len \cdot add \\

\sum_{i=l}^{r} (mul \cdot a_i + add)^2 &= \sum_{i=l}^{r} (mul^2 \cdot a_i^2 + 2 \cdot mul \cdot add \cdot a_i + add^2) \\
&= mul^2 \cdot \sum_{i=l}^{r} a_i^2 + 2 \cdot mul \cdot add \cdot \sum_{i=l}^{r} a_i + add^2 \cdot len \\
\end{aligned}
\]

区间修改需要设置懒标记。标记修改公式：

\[\begin{aligned}
& mul' \cdot (mul \cdot x + add) + add' \\
=& (mul' \cdot mul) \cdot x + (mul' \cdot add + add')
\end{aligned}
\]

时间复杂度 \(O((n+m) \log n)\)

空间复杂度 \(O(n)\)

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

template<class T, class F>
class SegmentTreeLazy {
    int n;
    vector<T> node;
    vector<F> lazy;

    void push_down(int rt) {
        node[rt << 1] = lazy[rt](node[rt << 1]);
        lazy[rt << 1] = lazy[rt](lazy[rt << 1]);
        node[rt << 1 | 1] = lazy[rt](node[rt << 1 | 1]);
        lazy[rt << 1 | 1] = lazy[rt](lazy[rt << 1 | 1]);
        lazy[rt] = F::e();
    }

    void update(int rt, int l, int r, int x, int y, F f) {
        if (l > y || r < x) return;
        if (x <= l && r <= y) return node[rt] = f(node[rt]), lazy[rt] = f(lazy[rt]), void();
        push_down(rt);
        int mid = l + r >> 1;
        update(rt << 1, l, mid, x, y, f);
        update(rt << 1 | 1, mid + 1, r, x, y, f);
        node[rt] = node[rt << 1] + node[rt << 1 | 1];
    }

    T query(int rt, int l, int r, int x, int y) {
        if (l > y || r < x) return T::e();
        if (x <= l && r <= y) return node[rt];
        push_down(rt);
        int mid = l + r >> 1;
        return query(rt << 1, l, mid, x, y) + query(rt << 1 | 1, mid + 1, r, x, y);
    }

public:
    SegmentTreeLazy(int _n = 0) { init(_n); }
    SegmentTreeLazy(int _n, const vector<T> &src) { init(_n, src); }

    void init(int _n) {
        n = _n;
        node.assign(n << 2, T::e());
        lazy.assign(n << 2, F::e());
    }
    void init(int _n, const vector<T> &src) {
        init(_n);
        function<void(int, int, int)> build = [&](int rt, int l, int r) {
            if (l == r) return node[rt] = src[l], void();
            int mid = l + r >> 1;
            build(rt << 1, l, mid);
            build(rt << 1 | 1, mid + 1, r);
            node[rt] = node[rt << 1] + node[rt << 1 | 1];
        };
        build(1, 1, n);
    }

    void update(int x, int y, F f) { update(1, 1, n, x, y, f); }

    T query(int x, int y) { return query(1, 1, n, x, y); }
};
struct T {
    ll len;
    ll val;
    ll val2;
    static T e() { return { 0,0,0 }; }
    friend T operator+(const T &a, const T &b) { return { a.len + b.len,a.val + b.val,a.val2 + b.val2 }; }
};
struct F {
    ll add;
    ll mul;
    static F e() { return { 0,1 }; }
    T operator()(const T &x) { return { x.len,mul * x.val + add * x.len,mul * mul * x.val2 + 2 * mul * add * x.val + add * add * x.len }; }
    F operator()(const F &g) { return { mul * g.add + add,mul * g.mul }; }
};

T a[10007];
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n >> m;
    for (int i = 1, x;i <= n;i++) {
        cin >> x;
        a[i] = { 1,x,1LL * x * x };
    }
    SegmentTreeLazy<T, F> sgt(n, vector<T>(a, a + n + 1));
    for (int i = 1;i <= m;i++) {
        int op, l, r, x;
        cin >> op >> l >> r;
        if (op == 1) {
            cout << sgt.query(l, r).val << '\n';
        }
        else if (op == 2) {
            cout << sgt.query(l, r).val2 << '\n';
        }
        else if (op == 3) {
            cin >> x;
            sgt.update(l, r, { 0,x });
        }
        else if (op == 4) {
            cin >> x;
            sgt.update(l, r, { x,1 });
        }
    }
    return 0;
}