[补题]你需偿还 (线段树)

D-你需偿还

题目本意就是求满足条件 $l\le {\sum }_{k=i}^j{a}_k\le r$ 的二元组 $(i,j)$ 的数量。
条件:

• $n\le 2\times 10^5$
• $-10^{15}\le l\le r\le 10^{15}$
• $1\le i\le j\le n$

思路：
前缀和数组求某段区间和，效率O(n)。

然后离散化加线段树，O（nlogn）
代码:

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

const int MAXN = 2e5 + 5;
long long a[MAXN], sum[MAXN];  // 定义原始数组 a 和前缀和数组 sum
vector<long long> all_sums;  // 定义向量存储所有的前缀和

// 定义线段树结构体
struct SegmentTree {
    int n;  // 线段树长度
    vector<int> tree;  // 存储线段树的向量

    SegmentTree(int size) : n(size), tree(4 * size, 0) {}  // 构造函数，初始化线段树

    // 线段树更新函数，更新指定位置的值
    void update(int node, int start, int end, int idx, int val) {
        if (start == end) {  // 如果开始和结束位置相同，更新节点值
            tree[node] += val;
        } else {  // 否则，取中点，并向下递归更新
            int mid = (start + end) / 2;
            if (start <= idx && idx <= mid) {
                update(2 * node, start, mid, idx, val);
            } else {
                update(2 * node + 1, mid + 1, end, idx, val);
            }
            // 更新后的节点值为两个子节点的和
            tree[node] = tree[2 * node] + tree[2 * node + 1];
        }
    }

    // 线段树查询函数，查询指定范围内的值之和
    int query(int node, int start, int end, int l, int r) {
        if (r < start || end < l) {  // 如果查询范围和当前节点不重合，返回0
            return 0;
        }
        if (l <= start && end <= r) {  // 如果查询范围包含当前节点，返回节点值
            return tree[node];
        }
        // 否则，取中点，向下递归查询两个子节点的值，并返回它们的和
        int mid = (start + end) / 2;
        int p1 = query(2 * node, start, mid, l, r);
        int p2 = query(2 * node + 1, mid + 1, end, l, r);
        return p1 + p2;
    }

    // 通过它来更新索引位置的值
    void update(int idx, int val) {
        update(1, 0, n - 1, idx, val);
    }

    // 通过它来查询范围的值
    int query(int l, int r) {
        return query(1, 0, n - 1, l, r);
    }
};

// 函数，用于在排序后的和向量中找到特定值的索引，如果没有找到，就返回应插入的位置
int getIndex(vector<long long>& v, long long x) {
    return lower_bound(v.begin(), v.end(), x) - v.begin();
}

int main() {
    ios::sync_with_stdio(false);  // 停用cin和cout的同步，提高输入输出效率
    cin.tie(0);  // 解除cin与cout的绑定，进一步提高输入输出效率

    // 输入数据
    int n;  // 数组元素数量
    long long l, r;  // 子数组和的目标范围
    cin >> n >> l >> r;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];  // 输入数组A
        sum[i] = sum[i - 1] + a[i];  // 计算前i项的和
        // 存储所有可能的前缀和，用于离散化
        all_sums.push_back(sum[i]);
        all_sums.push_back(sum[i] - l);
        all_sums.push_back(sum[i] - r - 1);
    }
    all_sums.push_back(0);  // 也考虑空子数组的和，即0

    // 对前缀和进行排序和去重，完成离散化
    sort(all_sums.begin(), all_sums.end());
    all_sums.erase(unique(all_sums.begin(), all_sums.end()), all_sums.end());

    // 初始化线段树
    SegmentTree st(all_sums.size());

    // 逐个处理前缀和，每次先查询，再更新
    long long result = 0;
    for (int i = 0; i <= n; i++) {
        result += st.query(getIndex(all_sums, sum[i] - r - 1) + 1,
                           getIndex(all_sums, sum[i] - l));
        st.update(getIndex(all_sums, sum[i]), 1);
    }

    // 输出结果
    cout << result << "\n";

    return 0;
}