题目链接

题目

题目描述

You have N integers, \(A_1, A_2, ... , A_N\) .You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The other is to ask for the sum of numbers in a given interval.

输入描述

The first line contains two numbers N and Q. \(1 \leq N,Q \leq 100000\) .
The second line contains N numbers, the initial values of \(A_1, A_2, ... , A_N\) \(-1000000000 \leq A_i \leq 1000000000\) .
Each of the next Q lines represents an operation.
"C a b c" means adding c to each of \(A_a, A_{a+1}, ... , A_b\) , \(10000 \leq c \leq 10000\) .
"Q a b" means querying the sum of \(A_a, A_{a+1}, ... , A_b\) .

输出描述

You need to answer all Q commands in order. One answer in a line.

示例1

输入

10 5
1 2 3 4 5 6 7 8 9 10
Q 4 4
Q 1 10
Q 2 4
C 3 6 3
Q 2 4

输出

4
55
9
15

备注

The sums may exceed the range of 32-bit integers.

题解

知识点：线段树。

线段树懒标记实现区间修改的板子题。

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

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

代码

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

struct T {
    int len;
    ll sum;
    static T e() { return { 0,0 }; }
    friend T operator+(const T &a, const T &b) { return { a.len + b.len, a.sum + b.sum }; }
};
struct F {
    ll add;
    static F e() { return { 0 }; }
    T operator()(const T &x) { return { x.len,x.sum + add * x.len }; }
    F operator()(const F &g) { return { g.add + add }; }
};
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 (r < x || y < l) 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 (r < x || y < l)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(const vector<T> &src) { init(src); }

    void init(int _n) {
        n = _n;
        node.assign(n << 2, T::e());
        lazy.assign(n << 2, F::e());
    }
    void init(const vector<T> &src) {
        assert(src.size());
        init(src.size() - 1);
        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); }
};

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, q;
    cin >> n >> q;
    vector<T> a(n + 1);
    for (int i = 1;i <= n;i++) {
        int x;
        cin >> x;
        a[i] = { 1,x };
    }
    SegmentTreeLazy<T, F> sgt(a);
    while (q--) {
        char op;
        int a, b;
        cin >> op >> a >> b;
        if (op == 'C') {
            int c;
            cin >> c;
            sgt.update(a, b, { c });
        }
        else cout << sgt.query(a, b).sum << '\n';
    }
    return 0;
}