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;
}