BZOJ3932 [CQOI2015]任务查询系统

Description

最近实验室正在为其管理的超级计算机编制一套任务管理系统，而你被安排完成其中的查询部分。超级计算机中的
任务用三元组(Si,Ei,Pi)描述，(Si,Ei,Pi)表示任务从第Si秒开始，在第Ei秒后结束（第Si秒和Ei秒任务也在运行
），其优先级为Pi。同一时间可能有多个任务同时执行，它们的优先级可能相同，也可能不同。调度系统会经常向
查询系统询问，第Xi秒正在运行的任务中，优先级最小的Ki个任务（即将任务按照优先级从小到大排序后取前Ki个
）的优先级之和是多少。特别的，如果Ki大于第Xi秒正在运行的任务总数，则直接回答第Xi秒正在运行的任务优先
级之和。上述所有参数均为整数，时间的范围在1到n之间（包含1和n）。

Input

输入文件第一行包含两个空格分开的正整数m和n，分别表示任务总数和时间范围。接下来m行，每行包含三个空格
分开的正整数Si、Ei和Pi(Si≤Ei)，描述一个任务。接下来n行，每行包含四个空格分开的整数Xi、Ai、Bi和Ci，
描述一次查询。查询的参数Ki需要由公式 Ki=1+(Ai*Pre+Bi) mod Ci计算得到。其中Pre表示上一次查询的结果，
对于第一次查询，Pre=1。

Output

输出共n行，每行一个整数，表示查询结果。

Sample Input

4 3
1 2 6
2 3 3
1 3 2
3 3 4
3 1 3 2
1 1 3 4
2 2 4 3

Sample Output

2
8
11

Sample Explaintion

K1 = (1*1+3)%2+1 = 1
K2 = (1*2+3)%4+1 = 2
K3 = (2*8+4)%3+1 = 3
对于100%的数据，1≤m,n,Si,Ei,Ci≤100000，0≤Ai,Bi≤100000，1≤Pi≤10000000，Xi为1到n的一个排列

Problem Address

BZOJ3932 洛谷P3168

Solution 差分数组 + 主席树

• 先介绍下差分数组的概念：令$b[1] = a[1], b[i] = a[i] - a[i - 1](2 \le i \le n)$，这样的数组$b$就是一个差分数组。
• 我们可以发现：
  $\sum \limits_{j = 1}^i b[j] = b[1] + b[2] + ... + b[i]$
  $= a[1] + a[2] - a[1] + ... + a[i - 1] + a[i] - a[i - 1] = a[i]$
• 那么通过前缀和就可来求单个位置的值，以此处理一些特殊的问题。例如本题中的修改，给区间$[l, r]$内的每个位置加上优先级$k$，那么我们只要令$b[l] += k, b[r + 1] -= k$，表示用前缀和求区间$[l, r]$内的元素时都会加上$k$，而区间$[r + 1, n]$的元素就会同时加上和减去$k$，也就是不变。
• 接下来，我们就可以用善于处理前缀和的主席树来求第$k$小优先级之和了。首先按位置存储下形如$b[l] += k, b[r + 1] -= k$的修改（由于同一位置上可能有多次修改，空间问题上应使用邻接表），其次对每个位置建权值线段树。对于同一位置的不同修改，我们可以用$spj$数组记录下最后一次修改完成后所建权值线段树的编号，直接在询问中使用即可。

Code

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;
typedef long long ll;
const int Maxn = 0x3f3f3f3f;
const int N = 2e5 + 5, M = 5e6 + 5;
ll Ans = 1; int n, m, L, E, fx, rt[N << 1], spj[N];

struct Edge
{
    int to; Edge *nxt;
}a[N << 1], *T = a, *lst[N];

struct point
{
    int num, lc, rc; ll sum;
    #define l(x) tr[x].lc
    #define r(x) tr[x].rc
    #define c(x) tr[x].num
    #define s(x) tr[x].sum
}tr[M];
//根据题意 1 <= Pi <= 10000000
//按照权值线段树的定义空间显然是不够的
//但考虑一共只有2m次插入，每次只增加log2m个节点
//所以我们这么开是没有问题的  

template <class T> inline void CkMax(T &a, const T &b) {if (a < b) a = b;}

inline int get()
{
    char ch; bool f = false; int res = 0;
    while (((ch = getchar()) < '0' || ch > '9') && ch != '-');
    if (ch == '-') f = true;
     else res = ch - '0';
    while ((ch = getchar()) >='0' && ch <= '9')
        res = (res << 3) + (res << 1) + ch - '0';
    return f? ~res + 1 : res;
}

inline void put(ll x)
{
    if (x < 0)
      x = ~x + 1, putchar('-');
    if (x > 9) put(x / 10);
    putchar(x % 10 + 48);
}

inline void addEdge(const int &x, const int &y)
{
    T->nxt = lst[x]; T->to = y; lst[x] = T++;
}

inline int Abs(const int &x) {return x < 0 ? ~x + 1 : x;}

inline void Insert(const int &y, int &x, const int &vi, const int &l, const int &r)
{
    tr[x = ++E] = tr[y]; c(x) += (vi < 0 ? -1 : 1); s(x) += vi;
    if (l == r) return ;
    int mid = l + r >> 1;
    if (Abs(vi) <= mid) Insert(l(y), l(x), vi, l, mid);
     else Insert(r(y), r(x), vi, mid + 1, r);
}

inline ll Query(const int &x, const int &l, const int &r, const int &k)
{
    if (l == r) return k * l;
    // 可能会有相同的优先级，应根据 k 的大小而不是全部记入答案
    int mid = l + r >> 1;
    if (k <= c(l(x))) return Query(l(x), l, mid, k);
     else return Query(r(x), mid + 1, r, k - c(l(x))) + s(l(x)); 
}


int main()
{
    m = get(); n = get(); int x, a, b, c, k, w;
    for (int i = 1; i <= m; ++i)
    {
        a = get(); b = get(); c = get();
        addEdge(a, c); addEdge(b + 1, ~c + 1); CkMax(fx, c);
    }   
    for (int i = 1; i <= n; ++i)
    {
        for (Edge *e = lst[i]; e; e = e->nxt)
         L++, Insert(rt[L - 1], rt[L], e->to, 1, fx);
        spj[i] = L; 
    }
    for (int i = 1; i <= n; ++i)
    {
        x = get(); a = get(); b = get(); c = get(); 
        k =((ll)a * Ans + b) % c + 1; w = rt[spj[x]];
        put(Ans = (c(w) <= k) ? s(w) : Query(w, 1, fx, k)), putchar('\n');
        // 注意 k 可能会越界
    }
    return 0;
}