bzoj3545-bzoj3551-Peaks

题意

给出一个图，边有边权，点有点权，每次询问一个点 \(x\) 只走边权小于等于 \(d\) 的边能到达的点中点权第 \(k\) 大。

强制在线，\(n\le 10^5,m,q\le 5\times 10^5\)

分析

如果可以离线的话，我们可以用一个并查集（路径压缩）维护连通性，在并查集的每个点上存一个权值线段树，每次merge的时候就把下面的线段树合并到上面。做kruskal最小生成树，从小到大每次加完一种权值的边后处理这里的询问。这样的复杂度为 \(O(n\log n\alpha(n))\) 。

然而现在是强制在线，引入一种新的数据结构——kruskal重构树（我也不知道为什么是这个名字）。它的思想非常简单。kruskal的时候我们是从小到大添加边，那么我们还是用类似并查集的方法，每次合并的时候新建一个点，把需要合并的两个点都挂在这个新点的下面，新点的权值为这条边的边权。这样我们会得到一棵树，它满足新点的结构组成一个大根堆。那么如果我们要查询从一个点出发，边权小于等于 \(d\) 的边能到达的点，其实就是从这个点不断往上跳，保证经过的每个新点 \(p\) 的权值都小于等于 \(d\) 。最后走到的这个新点的整个子树就是我们能够走到的点。

由于这棵树的高度没有保证，我们把这棵树建出来，做一个可持久化线段树的合并，倍增跳到合法的 \(p\) ，查询子树即可。复杂度为 \(O(n\log n)\)，非常优秀。

其实这题我还有一个想法。我们每次不新建点，而是按秩合并并查集，在每个点上开一个map，记录一下每个权值对应的线段树根，每次暴力往上跳到合法位置，在map上lower_bound以下，直接查询即可。复杂度也为 \(O(n\log n)\) 。

代码

这不是kruskal重构树，是我那个方法。

#include<bits/stdc++.h>
using namespace std;
inline char nchar() {
	static const int bufl=1<<20;
	static char buf[bufl],*a,*b;
	return a==b && (b=(a=buf)+fread(buf,1,bufl,stdin),a==b)?EOF:*a++;
}
inline int read() {
	int x=0,f=1;
	char c=nchar();
	for (;!isdigit(c);c=nchar()) if (c=='-') f=-1;
	for (;isdigit(c);c=nchar()) x=x*10+c-'0';
	return x*f;
}
inline void write(int x) {
	if (x==0) puts("0"); else if (x==-1) puts("-1"); else {
		static char s[20];
		int tot=0;
		for (;x;x/=10) s[++tot]=x%10+'0';
		while (tot) putchar(s[tot--]);
		puts("");
	}
}
const int maxn=1e5+1;
const int maxm=5e5+1;
const int inf=1e9+7;
int h[maxn],c[maxn],ls=0,n,m,q;
pair<int,pair<int,int> > e[maxm];
namespace sgt {
	const int maxp=5e6+1;
	struct node {
		int l,r,size;
	} t[maxp];
	int tot=0;
	void inc(int &x,int l,int r,int p) {
		if (!x) x=++tot;
		++t[x].size;
		if (l==r) return;
		int mid=(l+r)>>1;
		p<=mid?inc(t[x].l,l,mid,p):inc(t[x].r,mid+1,r,p);
	}
	inline void inc(int &x,int p) {inc(x,1,ls,p);}
	int merge(int x,int y,int l,int r) {
		if (!x) return y;
		if (!y) return x;
		int p=++tot,mid=(l+r)>>1;
		if (l==r) {
			t[p].size=t[x].size+t[y].size;
			return p;
		}
		t[p].l=merge(t[x].l,t[y].l,l,mid);
		t[p].r=merge(t[x].r,t[y].r,mid+1,r);
		t[p].size=t[t[p].l].size+t[t[p].r].size;
		return p;
	}
	int query(int x,int l,int r,int k) {
		if (l==r) return l;
		int mid=(l+r)>>1;
		return k<=t[t[x].l].size?query(t[x].l,l,mid,k):query(t[x].r,mid+1,r,k-t[t[x].l].size);
	}
	inline int query(int x,int k) {
		if (k==0 || k>t[x].size) return -1;
		return query(x,1,ls,t[x].size-k+1);
	}
}
namespace st {
	int rk[maxn],f[maxn],w[maxn],last[maxn];
	map<int,int> mp[maxn];
	inline void init(int n) {for (int i=1;i<=n;++i) rk[i]=0,w[i]=-1,f[i]=i;}
	int find(int x,int d=inf) {
		for (;f[x]!=x && w[x]<=d;x=f[x]);
		return x;
	}
	int uni(int x,int y,int v) {
		if (rk[x]>rk[y]) swap(x,y);
		f[x]=y,w[x]=v,rk[y]+=(rk[x]==rk[y]);
		int tmp=mp[y].rbegin()->second;
		int &rt=mp[y][v];
		rt=sgt::merge(rt?rt:tmp,mp[x].rbegin()->second,1,ls);
	}
	int query(int x,int val,int k) {
		int fx=find(x,val);
		map<int,int>::iterator it=mp[fx].upper_bound(val);
		int rt=(--it)->second;
		return sgt::query(rt,k);
	}
}
inline bool cmp(int x,int y) {return st::rk[x]<st::rk[y];}
int main() {
#ifndef ONLINE_JUDGE
	freopen("test.in","r",stdin);
#endif
	n=read(),m=read(),q=read();
	st::init(n);
	for (int i=1;i<=n;++i) c[++ls]=h[i]=read();
	sort(c+1,c+ls+1),ls=unique(c+1,c+ls+1)-c-1;
	for (int i=1;i<=n;++i) h[i]=lower_bound(c+1,c+ls+1,h[i])-c;
	for (int i=1;i<=m;++i) {
		int x=read(),y=read(),w=read();
		e[i]=make_pair(w,make_pair(x,y));
	}
	sort(e+1,e+m+1);
	for (int i=1;i<=n;++i) {
		sgt::inc(st::mp[i][-1],h[i]);
	}
	for (int i=1;i<=m;++i) {
		int &w=e[i].first,&x=e[i].second.first,&y=e[i].second.second;
		int fx=st::find(x),fy=st::find(y);
		if (fx!=fy) st::uni(fx,fy,w);
	}
	int ans=0;
	while (q--) {
		int x=read()^ans,val=read()^ans,k=read()^ans;
		ans=st::query(x,val,k);
		if (ans!=-1) ans=c[ans];
		write(ans);
		if (ans==-1) ans=0;
	}
	return 0;
}