NC17877 整数序列

题目链接

题目

题目描述

给出一个长度为n的整数序列 \(a_1,a_2,...,a_n\) ，进行 \(m\) 次操作，操作分为两类。

操作1：给出 \(l,r,v\) ，将 \(a_l,a_{l+1},...,a_r\) 分别加上 \(v\) ；

操作2：给出 \(l,r\) ，询问 \(\sum\limits_{i=l}^{r}sin(a_i)=l\)

输入描述

第一行一个整数 \(n\)

接下来一行 \(n\) 个整数表示 \(a_1,a_2,...,a_n\)

接下来一行一个整数 \(m\)

接下来 \(m\) 行，每行表示一个操作，操作1表示为1 l r v，操作2表示为2 l r

保证 \(1 \leq n,m,a_i,v \leq 200000\) ； \(1 \leq l \leq r \leq n\) ， \(v\) 是整数

输出描述

对每个操作2，输出一行，表示答案，四舍五入保留一位小数

保证答案的绝对值大于0.1，且答案的准确值的小数点后第二位不是4或5

数据随机生成（n,m人工指定，其余整数在数据范围内均匀选取），并去除不满足条件的操作2

示例1

输入

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

输出

0.3
-1.4
-0.3

题解

知识点：线段树，数学。

分析一下要维护哪些信息，首先要维护区间正弦和，需要维护区间加，先推一个区间加的公式：

\[\begin{aligned}
\sum_{i = l}^r sin(a_i + x) &= \sum_{i = l}^r sin(a_i)cos(x) + cos(a_i)sin(x) \\
&= cos(x) \sum_{i = l}^r sin(a_i) + sin(x)\sum_{i = l}^r cos(a_i)
\end{aligned}
\]

出现了 \(\displaystyle \sum_{i=l}^r cos(a_i)\) ，因此考虑再维护一个区间余弦和，同样推一下区间加的公式：

\[\begin{aligned}
\sum_{i = l}^r cos(a_i + x) &= \sum_{i = l}^r cos(a_i)cos(x) - sin(a_i)sin(x) \\
&= cos(x) \sum_{i = l}^r cos(a_i) - sin(x)\sum_{i = l}^r sin(a_i)
\end{aligned}
\]

可以看到只需要区间正弦和、余弦和就能维护了。

因此，区间信息只需要维护区间正弦和 \(ssum\)、区间余弦和 \(csum\) ，区间和直接加即可。

区间修改需要维护区间加 \(add\) ，之前的分析已经得到区间修改公式。

区间修改需要设置懒标记，标记修改做简单加法即可。

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

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

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct T {
    double ssum, csum;
    static T e() { return { 0,0 }; }
    friend T operator+(const T &a, const T &b) { return{ a.ssum + b.ssum,a.csum + b.csum }; }
};
struct F {
    ll add;
    static F e() { return { 0 }; }
    T operator()(const T &x) {
        return {
            x.ssum * cos(add) + x.csum * sin(add),
            x.csum * cos(add) - x.ssum * sin(add),
        };
    }
    F operator()(const F &f) { return { f.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() >= 2);
        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;
    cin >> n;
    vector<T> a(n + 1);
    for (int i = 1;i <= n;i++) {
        int x;
        cin >> x;
        a[i] = { sin(x),cos(x) };
    }
    SegmentTreeLazy<T, F> sgt(a);
    int q;
    cin >> q;
    cout << fixed << setprecision(1);
    while (q--) {
        int op, l, r;
        cin >> op >> l >> r;
        if (op == 1) {
            int x;
            cin >> x;
            sgt.update(l, r, { x });
        }
        else cout << sgt.query(l, r).ssum << '\n';
    }
    return 0;
}