小複習

二元搜尋樹

$\mathcal{O}(log_2 n)$ insert $x$ :
把自己 split 成 key < $x$ 和 key $\geq x$ 的兩塊 $a, b$
然後合併 $a, x, b$
$\mathcal{O}(log_2 n)$ erase $x$ :
把自己 split 成 key < $x$ 和 key $\geq x$ 的兩塊 $a, b$
再把 $b$ split 成 key $\leq x$ 和 key > $x$ 的兩塊 $c, d$
然後合併 $a, c, d$
$\mathcal{O}(log_2 n)$ query $x$ :
二分搜

其實 pri 值只有用在 merge 決定上下的時候
所以其實可以在那個時候再決定就好
可以發現若兩棵樹的大小分別是 $S_a, S_b$ ，那麼 $a$ 應該要在上層的機率約是 $\frac{S_a}{S_a + S_b}$
如果順便維護子樹的大小，那就可以在樹上二分搜求出第 $k$ 大的元素
在序列上，把 index 視為 key，則可以建出一個完整序列的 Treap，查詢區間時，只要把整格區間切下來並且維護子樹的資訊就好。可以做到線段樹支援的事情（只是比較慢....

維護一個序列，操作有以下

$\text{insert} p k v_1, v_2, v_3... v_k$ :
把 $k$ 個數字 $v_1, v_2, v_3...v_k$ 插入在第 $p$ 個數字的後面
$\text{delete} p k$ :
從第 $p$ 個數字開始連續刪除 $k$ 個數字
$\text{make-same} p k v$ : 把 $p$ 開始的連續 $k$ 數字都改成 $v$
$\text{reverse} p k$ : 把 $p$ 開始的連續 $k$ 個數字倒轉
$\text{get-sum} p k$ : 計算從 $p$ 開始的 $k$ 個數字的和
$\text{max-sum}$ : 計算目前整個數列中最大的連續和

請維護一個集合，使得他支援兩種操作：

$x \leq 10^5$

操作數量 $\leq 10^5$

有一些城市編號由 $1 ~ n$

有一些科學家想採集隕石樣本，而第 $i$ 個城市需要採集 $p_i$ 個

有 $k$ 筆事件兩兩事件時間差為 1 且按照時間順序 $l_i, r_i, a_i$ 表達在從 $[l_i, r_i]$ 都將會有 $a_i$ 顆隕石墜落

請輸出 $n$ 行代表在第 $i$ 座城市至少要多久才能完成樣本採集

$1 \leq n \leq 300000, 1 \leq k \leq 300000$

有兩種工作，總共有 n 個

第一種會佔用一個處理器使用從 $l_i$ 到 $r_i$ 的所有時間並且從頭到尾只能使用同一個處理器

第二種有完成期限，可以分配給不同的處理器，必須在 $d_i$ 之前完成，需要花 $w_i$ 的時間

請問至少需要幾個處理器才能完成所有工作

NOTE : 一個處理器在任何時刻都只能處理一個工作
第二種工作在任何時刻也最多只能被一個處理器處理

$l_i \leq\ r_i \leq 10^6$

$n \leq 10^5$

帶修改區間 $K$ 大

	void split(node* now, int key, node* &a, node* &b) {
	if (!now) {
	a = b = NULL;
	return;
	}
	if (now->key < key) {
	a = now;
	split(now->right, key, a->right, b);
	}
	else {
	b = now;
	split(now->left, key, a, b->left);
	}
	}

	node* add(node* old, int pos, int val) {
	node* res = new node(old), * now = res;
	int l = 1, r = n, m;
	res->val += val;
	while (l < r) {
	m = l + r >> 1;
	if (pos > m) {
	now->right = new node(old->right);
	now->right->val += val;
	now = now->right;
	old = old->right;
	r = m;
	}
	else {
	now->left = new node(old->left);
	now->left->val += val;
	now = now->left;
	old = old->left;
	l = m+1;
	}
	}
	return res;
	}

	struct bit{
	void shift(vector<node*> &nodes, int dir) {
	static const l_type = 0;
	for (auto &i : nodes) i = (dir == l_type ? i->left : i->right);
	}
	int left_sum(vector<node*> &nodes) {
	int res = 0;
	for (auto i : nodes) res += i->left->cnt;
	return res;
	}
	int query(int l, int r, int k) {
	vector<node*> lnode, rnode;
	for (int i = l;i;i ^= i & -i) lnode.pb(root[i]);
	for (int i = r;i;i ^= i & -i) rnode.pb(root[i]);
	int L = 1, R = n, M;
	while (L < r) {
	M = L + R >> 1;
	if (int lcnt = left_sum(rnode) - left_sum(lnode) ; lcnt >= k) {
	shift(rnode, 0), shift(lnode, 0);
	R = M;
	}
	else {
	k -= lcnt;
	shift(rnode, 1), shift(lnode, 1);
	L = M+1;
	}
	}
	return L;
	}
	};