[CQOI2015]任务查询系统 【可持久化线段树+差分】

传送门

最开始思路都想到差分了，但是没有继续想下去。

解题思路：利用差分来解决区间的问题，因为最多有 1e5 个任务，所以最多有 2e5 次修改，利用时间戳来建树，首先让新建的这棵树等于上一颗树，如果这次没有修改操作，就跳过，否则就在这一棵树上进行修改。

坑点：在进行询问时，如果碰到递归终点，不能返回该点的权值和，而应该返回 次数k * 权值，因为存在相同的优先级。
 

///#include<bits/stdc++.h>
///#include<unordered_map>
///#include<unordered_set>
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<cmath>
#include<queue>
#include<bitset>
#include<set>
#include<stack>
#include<map>
#include<list>
#include<new>
#include<vector>

#define MT(a, b) memset(a,b,sizeof(a)
#define lowbit(x) (x&(-x))
using namespace std;
typedef long long ll;
const double pai = acos(-1.0);
const double E = 2.718281828459;
const ll mod = 1e9 + 7;
const ll INF = 0x3f3f3f3f3f3f;
const double esp = 1e-6;
const int maxn = 1e5 + 5;

struct node {
    int ls, rs;
    ll cnt, sum;
} p[maxn * 80];
int root[maxn << 1], times;

///储存修改操作
struct node_e {
    int op, add, p; ///op=数量变化     ///add=优先级
} load[maxn << 1];      ///一共只有 2*m 次操作。
int head[maxn], sign;

void add_edge(int s, int op, int add) {
    load[++sign] = node_e{op, add, head[s]};
    head[s] = sign;
}

void insert(int &now, int old, int l, int r, int op) {
    now = ++times;
    p[now] = p[old], p[now].cnt += (ll) load[op].op, p[now].sum += (ll) load[op].add;
    if (l == r) return;
    int mid = (l + r) >> 1;
    if (abs(load[op].add) <= mid) insert(p[now].ls, p[old].ls, l, mid, op);
    else insert(p[now].rs, p[old].rs, mid + 1, r, op);
}

ll query(int now, int l, int r, ll k) {
    if (l == r) return k * (ll) l;      ///可能出现同样的优先级，不应该返回 p[now].sum，应该取数量*优先级
    int mid = (l + r) >> 1;
    ll x = p[p[now].ls].cnt;
    if (k <= x) return query(p[now].ls, l, mid, k);
    else return p[p[now].ls].sum + query(p[now].rs, mid + 1, r, k - x);
}

int main() {
    memset(head, -1, sizeof(head));
    int m, n, S, E, P, up = 0;   ///  m 任务总数   n 时间范围
    scanf("%d %d", &m, &n);
    for (int i = 1; i <= m; i++) {
        scanf("%d %d %d", &S, &E, &P);
        add_edge(S, 1, P), add_edge(E + 1, -1, -P);
        up = max(up, P);        ///寻找权值上限
    }
    for (int i = 1; i <= n; i++) {
        root[i] = root[i - 1];  ///i时刻的树等于i-1时刻的
        for (int j = head[i]; ~j; j = load[j].p) { insert(root[i], root[i], 1, up, j); }///这一个时刻的修改操作
    }
    ll X, A, B, C, pre = 1, K;
    for (int i = 1; i <= n; i++) {
        scanf("%lld %lld %lld %lld", &X, &A, &B, &C);
        K = 1LL + ((A * pre + B) % C);
        ///记住更新pre
        if (p[root[X]].cnt <= K) { printf("%lld\n", pre = p[root[X]].sum); }
        else printf("%lld\n", (pre = query(root[X], 1, up, K)));
    }
    return 0;
}