BZOJ.3551. [ONTAK2010]Peaks加强版

传送门

类似可以离线处理的题目Peaks
$Kruskal$重构树 强制在线，主要就考一个【重构树】以及【树链剖分】+【静态区间第K大】，离散化建立一颗权值线段树即可

重构树的性质，某点往根节点跳，找到能够其值等于$<=$限制值的最远的节点，此节点的所有子树的叶子节点均可在不超过该节点权值的情况下相互到达。也就是题中的连通块。通过树链剖分和主席树将这些叶子节点的区间信息维护起来找第$K$大（为什么能维护呢？子树在树剖过后是连续的区间）
既然是静态且在线的第$K$大，可以尝试使用划分树处理，效率也不会差。

代码

//bz3551
/*
  @Author: YooQ
*/
#include <bits/stdc++.h>
using namespace std;
#define sc scanf
#define pr printf
#define ll long long
#define int long long
#define FILE_OUT freopen("out", "w", stdout);
#define FILE_IN freopen("1.in", "r", stdin);
#define debug(x) cout << #x << ": " << x << "\n";
#define AC 0
#define WA 1
#define INF 0x3f3f3f3f
const ll MAX_N = 3e5+5;
const ll MOD = 1e9+7;
int N, M, K;

struct Tr {
	int k, l, r;
}tr[MAX_N*17];
int rindx = 0;
int root[MAX_N];

int clone(int rt) {
	tr[++rindx] = tr[rt];
	return rindx;
}

void push_up(int rt) {
	tr[rt].k = tr[tr[rt].l].k + tr[tr[rt].r].k;
}

void update(int& rt, int l, int r, int x, int k) {
	rt = clone(rt);
	if (l == r) {
		tr[rt].k += k;
		return;
	}
	int mid = l + ((r-l)>>1);
	if (x <= mid) update(tr[rt].l, l, mid, x, k);
	if (x  > mid) update(tr[rt].r, mid+1, r, x, k);
	push_up(rt);
}

int query(int p, int q, int l, int r, int k) {
	if (!q || tr[q].k - tr[p].k < k) return 0;
	if (l == r) return l;
	int mid = l + ((r-l)>>1);
	int rsum = tr[tr[q].r].k - tr[tr[p].r].k;
	if (rsum >= k) return query(tr[p].r, tr[q].r, mid+1, r, k);
	return query(tr[p].l, tr[q].l, l, mid, k - rsum);
}

int head[MAX_N];
int tot = 0;
struct Edge{
	int to, nxt;
}edge[MAX_N];

void addEdge(int u, int v) {
	edge[tot].nxt = head[u];
	edge[tot].to = v;
	head[u] = tot++;
}

struct Node {
	int u, v, w;
	bool operator < (const Node& B) const {
		return w < B.w;
	}
}node[MAX_N*3];

int parent[MAX_N];

int find(int x) {
	return x==parent[x]?x:parent[x]=find(parent[x]);
}

int brr[MAX_N];
int indx = 0;

int father[MAX_N][21];

int L[MAX_N];
int sa[MAX_N];
int R[MAX_N];
int dfncnt = 0;

void dfs(int u, int from) {
	father[u][0] = from;
	L[u] = dfncnt;
	for (int i = 1; i <= 20; ++i) {
		father[u][i] = father[father[u][i-1]][i-1];
	}
	if (head[u] == -1) {
		sa[R[u] = ++dfncnt] = u;
		return;
	}
	for (int i = head[u];~i;i=edge[i].nxt) {
		dfs(edge[i].to, u);
	}
	R[u] = dfncnt;
}

int arr[MAX_N];
int uniarr[MAX_N];
int unicnt = 0;

int ask(int v, int x, int k) {
	for (int i = 20; i+1; --i) {
		if (brr[father[v][i]] <= x) v = father[v][i];
	}
	return uniarr[query(root[L[v]], root[R[v]], 1, unicnt, k)];
}

void init() {
	memset(head, -1, sizeof head);
	tot = 0;
}

void solve(){
	init();
	sc("%lld%lld%lld", &N, &M, &K);
	for (int i = 1; i <= N; ++i) {
		sc("%lld", &arr[i]);
		uniarr[i] = arr[i];
	}
	
	unicnt = N;
	sort(uniarr+1, uniarr+1+N);
	unicnt = unique(uniarr+1, uniarr+1+N) - uniarr - 1;
	
	for (int i = 1; i <= 2*N; ++i) {
		parent[i] = i;
	}
	for (int i = 1; i <= M; ++i) {
		sc("%lld%lld%lld", &node[i].u, &node[i].v, &node[i].w);
	}
	sort(node+1, node+1+M);
	
	int x, y;
	indx = N;
	for (int i = 1; i <= M; ++i) {
		x = find(node[i].u);
		y = find(node[i].v);
		if (x != y) {
			parent[x] = parent[y] = ++indx;
			brr[indx] = node[i].w;
			addEdge(indx, x);
			addEdge(indx, y);
		}
	}
	dfs(indx, indx);
	
	for (int i = 1; i <= N; ++i) {
		arr[sa[i]] = lower_bound(uniarr+1, uniarr+1+unicnt, arr[sa[i]]) - uniarr;
		root[i] = root[i-1];
		update(root[i], 1, unicnt, arr[sa[i]], 1);
	}
	
	uniarr[0] = -1;
	
	int k = 0, pre = 0, ans;
	for (int i = 1; i <= K; ++i) {
		sc("%lld%lld%lld", &x, &y, &k);
		if (pre != -1) {
			x = pre ^ x;
			y = pre ^ y;
			k = pre ^ k;
		}
		if (x>N) {
			puts("-1");
			continue;
		}
		ans = ask(x, y, k);
		pr("%lld\n", ans);
		pre = ans;
	}
}

signed main()
{
	#ifndef ONLINE_JUDGE
	FILE_IN
	FILE_OUT
	#endif
	int T = 1;//cin >> T;
	while (T--) solve();

	return AC;
}