[CQOI2015]任务查询系统 (可持久化treap)

题意：有n个任务。每个任务描述为(s,e,p)表示起始、结束时间、优先级。M次询问，查询i时刻优先级排前k的任务的优先级之和。如果k超过那个时刻运行任务的总量，输出那个时刻所以优先级之和。强制在线。

s,e<=10w, p<=1000w, n,m<=10w.

哎呀我去这么裸的主席树为什么去年省选只有一个人A了？

开始看做插入一个数，结束看做删除，询问就是问第i个版本中前k个之和。先把p离散化，然后扫描一遍用主席树来维护p值。好像没什么坑点。。

不想写离散化。。这两天玩treap有点玩上火了，就写个可持久化平衡树吧2333

事实证明之前没写过的东西直接拿来做题对我这种傻叉来说比较蛋疼。。不过好在这道题实在是太裸了还是在三个小时以内把它调出来了（主要是没实现过平衡树的可持久化呀QAQ大部分时间检查模板去了）。

由于要可持久化，基于旋转的平衡树是要死的（有指针间接指向待修改节点的节点统统要修改，每次旋转带来的新建节点是O(logn)的，期望的总旋转次数为O(mlogn)，所以无论是时间还是空间都会退化为O(mlog^2n)不太和谐）。而非旋转式treap一次修改期望新建节点是O(logn)的。插入和删除都是基于一次get_rank加上总共三次split/merge实现，常数比较大，而且空间对常数比时间对常数敏感得多，所以可持久化treap对空间需求量比主席树大一点。所以如果不是内存限制512MB或者1024MB最好不要用可持久化treap而是尽量用离散化+主席树（不过貌似gmr大神掌握了不用离散的写法）。

有一些技巧，一开始如果有一个较长的初始序列的话，建初始序列的时候可以不用函数式，直接建即可，省不少内存。但这题上体现不明显。还有就是不用保存修正值，可以直接用clj说的随机启发式合并。还有貌似这个模板由于种种巧妙的地方可以直接对空树进行merge来插入而不需要任何特判，所以如果之前一个版本是空节点的话就不要copy之前的根了否则会多出来一个权值为0的节点影响答案。

注意merge的时候要返回新建的节点而不是原来的节点！！坑了我一个小时！！

#include<iostream>
#include<cassert>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;++i)
#define erp(i,a,b) for(int i=a;i>=b;--i)
#define fi first
#define se second
#define LL long long
using namespace std;
const int MAXN = 100002;
const int MAXS = MAXN * 100;
typedef pair<int, int> pii;
int N, M;
vector< pii > tab[MAXN];

inline int ran()
{
	static int sd = 1237;
	return sd = (sd*12371237)&0x7fffffff;
}

int rw[MAXN]; //每天多少任务
struct Treap
{
	int lch[MAXS], rch[MAXS], sz[MAXS], val[MAXS];
	LL sum[MAXS];
	int ncnt, rt[MAXN];

	Treap() { ncnt = rt[0] = 0; }

	inline void pushup(int x)
	{
		sz[x] = sz[lch[x]] + sz[rch[x]] + 1;
		sum[x] = sum[lch[x]] + sum[rch[x]] + val[x];
	}

	int NewNode(int i = 0)
	{
		++ncnt;
		val[ncnt] = sum[ncnt] = i;
		sz[ncnt] = 1;
		return ncnt;
	}

	int CopyNode(int x)
	{
		++ncnt;
		lch[ncnt] = lch[x];
		rch[ncnt] = rch[x];
		sz[ncnt] = sz[x];
		val[ncnt] = val[x];
		sum[ncnt] = sum[x];
		return ncnt;
	}

	inline bool rand_cmp(int a, int b)
	{
		return ran()%(sz[a]+sz[b]) < sz[a];
	}

	int merge(int a, int b)
	{
		if (!a || !b) return a+b;
		int r;
		if (rand_cmp(a, b))
		{
			r = CopyNode(a);
			rch[r] = merge(rch[a], b);
		}
		else
		{
			r = CopyNode(b);
			lch[r] = merge(a, lch[b]);
		}
		return pushup(r), r;
	}

	pii split(int x, int k)
	{
		if (!x) return pii(0, 0);
		pii y;
		int r;
		if (sz[lch[x]] >= k)
		{
			y = split(lch[x], k);
			r = CopyNode(x);
			lch[r] = y.se, y.se = r;
		}
		else
		{
			y = split(rch[x], k - sz[lch[x]] - 1);
			r = CopyNode(x);
			rch[r] = y.fi, y.fi = r;
		}
		return pushup(r), y;
	}

	int getRank(int x, const int&v)
	{
		if (!x) return 0;
		if (v < val[x]) return getRank(lch[x], v);
		return sz[lch[x]] + 1 + getRank(rch[x], v);
	}

	void FuncIns(int&r, const int&v)
	{
		int k = getRank(r, v);
		pii t = split(r, k);
		int x = NewNode(v);
		r = merge(merge(t.fi, x), t.se);
	}

	void FuncDel(int&r, const int&v)
	{
		int k = getRank(r, v);
		pii t1 = split(r, k-1);
		pii t2 = split(t1.se, 1);
		r = merge(t1.fi, t2.se);
	}

	LL qsum(int x, int k) //前k大的和
	{
		if (!x || !k) return 0;
		if (k <= sz[lch[x]]) return qsum(lch[x], k);
		return sum[lch[x]] + val[x] + qsum(rch[x], k - sz[lch[x]] - 1);
	}

	void dealDay(int d)
	{
		if (sz[rt[d-1]] != 0)
			rt[d] = CopyNode(rt[d - 1]);
		rep(i, 0, (int)tab[d].size()-1)
		{
			int op = tab[d][i].fi, x = tab[d][i].se;
			if (op == 1) FuncIns(rt[d], x);
			else FuncDel(rt[d], x);
		}
	}

	LL quary(int d, int k)
	{
		if (k >= rw[d]) return sum[rt[d]];
		return qsum(rt[d], k);
	}

} tp;

LL pre = 1;
int main()
{
	scanf("%d%d", &N, &M);
	int s, e, p, x, a, b, c, k;
	rep(i, 1, N)
	{
		scanf("%d%d%d", &s, &e, &p);
		rw[s]++, rw[e+1]--;
		tab[s].push_back(pii(1, p));
		tab[e+1].push_back(pii(-1, p));
	}
	rep(i, 1, M)
	{
		rw[i] += rw[i-1];
		tp.dealDay(i);
	}
	while (M --)
	{
		scanf("%d%d%d%d", &x, &a, &b, &c);
		k = 1 + (pre*a+b)%c;
		pre = tp.quary(x, k);
		cout << pre << '\n';
	}
	return 0;
}