【2019牛客暑期多校训练营 第七场 E题】【Find the median】【离散化+线段树】

题目链接：
https://ac.nowcoder.com/acm/contest/887/E
题意：
N次插入操作，忘数列$a$中插入$R_i-L_i+1$个数：$L_i,L_i+1,L_i+2,\cdot \cdot \cdot ,R_i-1,R_i$，问插入后数列$a$的中位数
题解：
这里需要一种支持插入查询的数据结构，很容易想到就是线段树或者树状数组，这里用线段树来做
每次插入的数$[L_i,R_i]$都是随机生成的，而且范围在$[1,10^{18}]$，因此需要对区间进行离散化
这里就有一个问题，离散化前，某一个小区间的长度就是$r-l+1$，那么离散化后会怎么样呢？
这里用$q[i]$表示$i$原值，那么区间长度是$q[r]-q[l]+1$吗？
显然不是。因为原来这个$+1$是因为每个点与点之间的距离是$1$,但是离散化后，这个距离就变了
因此实际上是 $q[r+1]-q[l]$ ，想清楚这个之后，这题就不难写出来了。
代码：

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define sz sizeof
#define lc u<<1
#define rc u<<1|1
#define m (l+r)/2
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> Pair;
const int MAX = 8e5 + 10;

int N;
ll A1, A2, B1, B2, C1, C2, M1, M2;
ll X[MAX], Y[MAX], L[MAX], R[MAX], q[MAX << 1];

struct SegTree {
	ll l, r;
	ll siz, tag, len;
	inline void add(int n) {
		siz += len * n;
		tag += n;
	}
}t[MAX << 2];

inline void build(int u, ll l, ll r) {
	t[u].l = l, t[u].r = r, t[u].tag = t[u].siz = 0;
	if (l == r) {
		t[u].len = q[l + 1] - q[l];
		return;
	}
	build(lc, l, m); build(rc, m + 1, r);
	t[u].len = t[lc].len + t[rc].len;
}

inline void push_up(int u) { t[u].siz = t[lc].siz + t[rc].siz; }

inline void push_down(int u) {
	if (t[u].tag) {
		t[lc].add(t[u].tag);
		t[rc].add(t[u].tag);
		t[u].tag = 0;
	}
}

inline void update(int u, ll l, ll r) {
	if (t[u].l >= l && t[u].r <= r) {
		t[u].add(1);
		return;
	}
	push_down(u);
	int mid = (t[u].l + t[u].r) / 2;
	if (l <= mid)update(lc, l, r);
	if (r > mid)update(rc, l, r);
	push_up(u);
}

inline ll query(int u, ll k) {
	int l = t[u].l, r = t[u].r;
	if (l == r) {
		ll num = t[u].siz / t[u].len;
		return q[l] + (k - 1) / num;
	}
	push_down(u);
	if (k > t[lc].siz)return query(rc, k - t[lc].siz);
	else return query(lc, k);
}

int main() {
#ifdef ACM_LOCAL
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	cin >> N;
	cin >> X[1] >> X[2] >> A1 >> B1 >> C1 >> M1;
	cin >> Y[1] >> Y[2] >> A2 >> B2 >> C2 >> M2;
	int cnt = 0;
	for (int i = 1; i <= N; i++) {
		if (i > 2) {
			X[i] = ((A1 * X[i - 1]) % M1 + (B1 * X[i - 2]) % M1 + C1) % M1;
			Y[i] = ((A2 * Y[i - 1]) % M2 + (B2 * Y[i - 2]) % M2 + C2) % M2;
		}
		L[i] = min(X[i], Y[i]) + 1;
		R[i] = max(X[i], Y[i]) + 2;
		q[++cnt] = L[i];
		q[++cnt] = R[i];
	}
	sort(q + 1, q + 1 + cnt);
	cnt = unique(q + 1, q + 1 + cnt) - q - 1;
	build(1, 1, cnt - 1);
	ll tot = 0;
	for (int i = 1; i <= N; i++) {
		tot += R[i] - L[i];
		L[i] = lower_bound(q + 1, q + 1 + cnt, L[i]) - q;
		R[i] = lower_bound(q + 1, q + 1 + cnt, R[i]) - q;
		update(1, L[i], R[i] - 1);
		cout << query(1, (tot + 1) / 2) << endl;
	}
	return 0;
}