NC25879 外挂

题目链接

题目

题目描述

我的就是我的，你也是我的，记住了，狐狸！

​ ——韩信-白龙吟

对于打赌输了的小T会遭受到制裁，小s修改了数据库使他可以派出许多军队来围攻小T.

很不幸，小T与小s打赌打输了，现在小T遭受着枪林弹雨与十面埋伏，因为小T是神所以他决定要扭转局势。

他要修改数据库！

数据总库的信号墙有n个电极插头，每个插头有一个信号 \(a_i\) ,

小T可以使在区间 \([\ l,r\ ]\) 内的所有信号加上一个值k。

对于区间 \([\ l,r\ ]\) 的信号强度有一个计算公式：

我们定义： \(f(k)=a_k \times \sum_{j=k+1}^r a_j\) 。

则信号强度就为： \(\sum_{i=l}^r f(i)\) 。

你可以认为f(i)就是第i个插头的信号强度。

现在小T一会儿修改信号值，一会儿询问信号强度，你是数据库的管理员，为了不被小TD，所以你要告诉他信号强度是多少。

注:本系列题不按难度排序哦

输入描述

第一行两个整数n,Q

第二行n个整数代表a

后Q行代表操作：

一操作： \(1\ l\ r\ x\) 代表区间 \([\ l,r\ ]\) 加x。

二操作： \(2\ l\ r\) 代表区间询问。

输出描述

每一行一个数字，表示对于一个二操作的答案。

示例1

输入

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

输出

6

说明

样例解释:1 1 2 1使a[1]~a[2]的值每个都加了1， 即a[1]=2, a[2]=3,所以2 1 2=a[1] *a[2]=2 * 3=6

保证所有二操作的答案都是在long long范围内（如果你不相信，可以写高精）。
时空限制为标程的5倍，放心卡常。

备注

\(100 \% \ \ 1 \le n,Q \le 10^5\)

对于所有 \(a_i \le 100\)

题解

知识点：线段树，数学。

注意到

\[\begin{aligned}
\left( \sum_{i = l}^r a_i \right)^2 &= \sum_{i = l}^r a_i^2 + 2\sum_{i = 1}^r \sum_{j = i+1}^r a_ia_j
\end{aligned}
\]

因此

\[\begin{aligned}
\sum_{i=l}^r f(i) = \sum_{i = 1}^r \sum_{j = i+1}^r a_ia_j &= \dfrac{1}{2} \left( \left( \sum_{i = l}^r a_i \right)^2 - \sum_{i = l}^r a_i^2 \right)
\end{aligned}
\]

所以用线段树维护区间和、区间平方和即可。

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

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

代码

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

struct T {
    ll len;
    ll sum;
    ll sum2;
    static T e() { return { 0, 0, 0 }; }
    friend T operator+(const T &a, const T &b) {
        return {
            a.len + b.len,
            a.sum + b.sum,
            a.sum2 + b.sum2
        };
    }
};
struct F {
    ll add;
    static F e() { return { 0 }; }
    T operator()(const T &x) {
        return {
            x.len,
            x.sum + x.len * add,
            x.sum2 + 2 * x.sum * add + x.len * add * add
        };
    }
    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,x * x };
    }
    SegmentTreeLazy<T, F> sgt(a);
    while (q--) {
        int op, l, r;
        cin >> op >> l >> r;
        if (op == 1) {
            int x;
            cin >> x;
            sgt.update(l, r, { x });
        }
        else {
            auto [len, sum, sum2] = sgt.query(l, r);
            cout << (sum * sum - sum2) / 2 << '\n';
        }
    }

    return 0;
}