BZOJ3551 [ONTAK2010]Peaks加强版

[Solution]

It's easy to come up with the conclusion that you can convert the problem into queries on a minimal spanning tree. You need to find the k-th max value of a piece that the edge values are no more than x.

However, it's not easy to find a piece because the may be not continuous on the DFS order, while I'm not able to have other ways to deal with a piece.

We can consider like this: we make a tree in the order of disjointing set. For each merging, we create a new node which has a value of the original edge's value. Therefore, the sons of a node can be always merged using edges whose values are no more than x.

We make a DFS in that order. And use chairman tree to modify the k-th height.

[Code]

It's so long and ugly. Because i was afraid of MLE, I used dynamic memory management.

#include <cstdio>
#include <cstdlib>
#include <memory.h>
#include <ctype.h>
#include <algorithm>

using namespace std;

struct edgeG {
	int a, b, v;
};
struct edgeT {
	int t;
	edgeT* next;
};
struct seg {
	int s;
	seg *ls, *rs;
};

const int maxp = 100010;
const int maxn = 200010;
const int maxe = 500010;
const int maxl = 22;
const int psz = 800000;
const int maxm = 1000000010;
const int inf = 0x3f3f3f3f;

edgeG eo[maxe];
edgeT *head[maxn], *ep;
seg *sp, *rt[maxn];
int n, m, tq, t, csn, lans, h[maxn];
int r[maxn], v0[maxn];
int dfb[maxn], dfe[maxn], odf[maxn], dfo;
int ath[maxn][maxl], mvl[maxn][maxl];

int nextInt() {
	int s = 0, d;
	bool flag = 0;
	do {
		d = getchar();
		if (d == '-')
			flag = 1;
	} while (!isdigit(d));
	do 
		s = s * 10 + d - 48, d = getchar();
	while (isdigit(d));
	return flag ? -s : s;
}

inline bool cmpEdgeG(edgeG a, edgeG b) {
	return a. v < b. v;
}

inline void addEdge(int u, int v) {
   ep-> t = v;
   ep-> next = head[u];
   head[u] = ep ++;
}

inline seg* newSeg() {
	return (!csn) ? (csn = psz, sp = new seg[psz + 2]) : (csn --, ++ sp);
}

inline int getRoot(int x) {
	return (r[x] == x) ? x : (r[x] = getRoot(r[x]));
}

#define getls(x) ((x)?(x->ls):0)
#define getrs(x) ((x)?(x->rs):0)
#define getsum(x) ((x)?(x->s):0)

seg* sgtIns(seg* q, int p0) {
	int l = 0, r = maxm;
	seg *s = newSeg(), *p = s;
	while (l < r) {
		int m = (l + r) >> 1;
		p-> s = getsum(q) + 1;
		if (p0 <= m) {
			r = m;
			p-> rs = getrs(q);
			q = getls(q);
			p-> ls = newSeg();
			p = p-> ls;
		}
		else {
			l = m + 1;
			p-> ls = getls(q);
			q = getrs(q);
			p-> rs = newSeg();
			p = p-> rs;
		}
	}
	p-> s = getsum(q) + 1;
	return s;
}

int sgtKth(seg *q, seg *p, int k) {
	if (getsum(p) - getsum(q) < k)
		return -1;
	int l = 0, r = maxm;
	while (l < r) {
		int sr = getsum(getrs(p)) - getsum(getrs(q));
		int m = (l + r) >> 1;
		if (sr >= k) {
			l = m + 1;
			p = getrs(p);
			q = getrs(q);
		}
		else {
			k -= sr;
			r = m;
			p = getls(p);
			q = getls(q);
		}
	}
	return l;
}

void dfs(int p) {
	dfb[p] = ++ dfo;
	odf[dfo] = p;
	for (int i = 1; i < maxl; i ++) {
		ath[p][i] = ath[ath[p][i - 1]][i - 1];
		mvl[p][i] = max(mvl[p][i - 1], mvl[ath[p][i - 1]][i - 1]);
	}
	for (edgeT* g = head[p]; g; g = g-> next) {
		ath[g-> t][0] = p;
		mvl[g-> t][0] = v0[p];
		dfs(g-> t);
	}
	dfe[p] = dfo;
}

void pre() {
	sort(eo, eo + m, cmpEdgeG);
	t = n;
	for (int i = 1; i <= n * 2; i ++)
		r[i] = i, v0[i] = 0;
	for (int i = 0; i < m; i ++)
		if (getRoot(eo[i]. a) != getRoot(eo[i]. b)) {
			t ++;
			h[t] = -1;
			v0[t] = eo[i]. v;
			addEdge(t, getRoot(eo[i]. a));
			addEdge(t, getRoot(eo[i]. b));
			r[getRoot(eo[i]. a)] = t;
			r[getRoot(eo[i]. b)] = t;
		}
	t ++;
	for (int i = 1; i < t; i ++)
		if (r[i] == i)
			addEdge(t, i);
	dfo = 0;
	ath[t][0] = 0;
	mvl[t][0] = inf;
	v0[t] = inf;
	dfs(t);
	rt[0] = 0;
	for (int i = 1; i <= t; i ++)
		if (h[odf[i]] > -1)
			rt[i] = sgtIns(rt[i - 1], h[odf[i]]);
		else
			rt[i] = rt[i - 1];
}

int query(int p, int x, int k) {
	for (int i = maxl - 1; i >= 0; i --)
		if (mvl[p][i] <= x)
			p = ath[p][i];
	return sgtKth(rt[dfb[p] - 1], rt[dfe[p]], k);
}

int main() {
#ifndef ONLINE_JUDGE
	freopen("in.txt", "r", stdin);
#endif

	memset(head, 0, sizeof(head));
	ep = new edgeT[maxn * 2];
	csn = 0;
	n = nextInt();
	m = nextInt();
	tq = nextInt();
	for (int i = 1; i <= n; i ++)
		h[i] = nextInt();
	for (int i = 0; i < m; i ++) {
		eo[i]. a = nextInt();
		eo[i]. b = nextInt();
		eo[i]. v = nextInt();
	}
	pre();
	lans = 0;
	while (tq --) {
		if (lans == -1)
			lans = 0;
		int v = nextInt() ^ lans;
		int x = nextInt() ^ lans;
		int y = nextInt() ^ lans;
		printf("%d\n", (lans = query(v, x, y)));
	}
}