洛谷4197 Peaks（克鲁斯卡尔重构树+主席树）伪克鲁斯卡尔重构树学习笔记

其实之前做归程那个题的时候，已经学习克鲁斯卡尔重构树，但是由于没有写博客，所以一直没有学习笔记。

qwq借着这个题，顺便说一下克鲁斯卡尔重构树吧。

克鲁斯卡尔重构树。
假设我们要求一个最小生成树的克鲁斯卡尔重构树的话，首先，先排好序，然后对于一条边来说，我们新建一个新点表示这条边，点权设成这条边的边权，然后将两个端点所在的联通块的$fa$设置成新建的点。

那么经过这样一番操作过后，对于一颗子树来说，权值最大的点就是这个子树的根，那么如果我们要询问类似只经过边权小于$k$的边，就可以直接跳到对应的点，然后那个子树内的所有叶子，就是能到的所有点。

那么回到这个题，首先，我们考虑建出来重构树之后呢，对于每个询问。
可以用二分的方式从给定的那个起点向上跳，跳到一个合适的点，那么子树内的所有叶子就是能到的所有的点。

那么问题就转化成了求子树内第k小的问题。

可以直接通过维护$dfs$序+主席树来实现。

但是这里有一个需要注意的小细节

我们要统计的是叶子节点的权值，也不是新建的那些节点，所以一开始建主席树的时候，只有叶子节点才$modify$，否则继承上一个节点就行。

// luogu-judger-enable-o2
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
#include<cmath>
#include<map>
#include<set>
#define pb push_back
#define mk make_pair
#define ll long long
#define lson ch[x][0]
#define rson ch[x][1]

using namespace std;

inline int read()
{
  int x=0,f=1;char ch=getchar();
  while (!isdigit(ch)) {if (ch=='-') f=-1;ch=getchar();}
  while (isdigit(ch)) {x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}
  return x*f;
}

const int maxn = 1e6+1e2;
const int maxm = 2*maxn;
const int inf = 1e9;

int point[maxn],nxt[maxm],to[maxm];
int cnt,n,m,q;
int deep[maxn],f[maxn][21];
int root[maxn];
int tmp,tot;
int dfn[maxn],back[maxn];
int val[maxn];
int size[maxn];
vector<int> v;
int h[maxn];
int sz;

struct Edge{
  int u,v,w;
};

Edge e[maxn];

struct Node{
	int l,r,val;
};

Node t[maxn*20];

void addedge(int x,int y)
{
	nxt[++cnt]=point[x];
	to[cnt]=y;
	point[x]=cnt;
}

void up(int root)
{
	t[root].val=t[t[root].l].val+t[t[root].r].val;
}

int modify(int pre,int l,int r,int x)
{
	int now = ++tot;
	if (l==r)
	{
		t[now].val=t[pre].val+1;
		return now;
	}
	int mid = l+r >> 1;
	if (x<=mid) 
	{
		t[now].r=t[pre].r;
		t[now].l=modify(t[pre].l,l,mid,x);
	}
	else
	{
		t[now].l=t[pre].l;
		t[now].r=modify(t[pre].r,mid+1,r,x);
	}
	up(now);
	return now;
}

int query(int root1,int root2,int l,int r,int k)
{
	if (l==r) return l;
	int mid = l+r >> 1;
	int vall = t[t[root2].r].val-t[t[root1].r].val;
	if (vall>=k) return query(t[root1].r,t[root2].r,mid+1,r,k);
	else return query(t[root1].l,t[root2].l,l,mid,k-vall); 
}

int fa[maxm];

bool cmp(Edge a,Edge b)
{
	return a.w<b.w;
}

int find(int x)
{
	if (fa[x]!=x) fa[x]=find(fa[x]);
	return fa[x];
}

void kruskal()
{
	for (int i=1;i<=m;i++)
	{
		int f1 = find(e[i].u);
		int f2 = find(e[i].v);
		if (f1==f2) continue;
		++n;
		fa[f1]=n;
		fa[f2]=n;
		addedge(n,f1);
		addedge(n,f2);
		addedge(f1,n);
		addedge(f2,n);
		val[n]=e[i].w;
	//	cout<<e[i].u<<" "<<e[i].v<<" "<<e[i].w<<"****\n";
	}
}

int tag[maxn];
int ymh[maxn];

void dfs(int x,int fa,int dep)
{
	dfn[x]=++tmp;
	back[tmp]=x;
	deep[x]=dep;
	size[x]=1;
	if (tag[x]) ymh[x]=1;
	for (int i=point[x];i;i=nxt[i])
	{
		int p = to[i];
		if (p==fa) continue;
		f[p][0]=x;
		dfs(p,x,dep+1);
		size[x]+=size[p];
		ymh[x]+=ymh[p];
	}
}

void init()
{
	for (int j=1;j<=20;j++)
	  for (int i=1;i<=n;i++)
	  {
	  	 f[i][j]=f[f[i][j-1]][j-1];
	  }
}

int getnum(int x)
{
	return lower_bound(v.begin(),v.end(),x) - v.begin() +1;
}


int go_up(int x,int d)
{
	for (int i=0;i<=20;i++)
	{
		if (d&(1<<i)) x=f[x][i];
	}
	return x;
}
int solve(int x,int y)
{
	int l=0,r=deep[x];
	int ans=x;
	while (l<=r)
	{
		int mid = l+r >> 1;
		int tt = go_up(x,mid);
		if (val[tt]<=y) l = mid+1,ans=tt;
		else r=mid-1;
	}
	return ans;
}
int main()
{
  n=read(),m=read(),q=read();
  for (int i=1;i<=n;i++) h[i]=read(),fa[i]=i,v.pb(h[i]),tag[i]=1;
  for (int i=1;i<=n+m;i++) fa[i]=i;
  for (int i=1;i<=m;i++)
  {
  	 e[i].u=read();
  	 e[i].v=read();
  	 e[i].w=read();
  }
  sort(e+1,e+1+m,cmp);
  kruskal();
  dfs(n,0,0);
  init();
  sort(v.begin(),v.end());
  sz = unique(v.begin(),v.end())-v.begin();
  v.resize(sz);
  for (int i=1;i<=n;i++)
  {
  	 if (tag[back[i]] ==0) root[i]=root[i-1];
	 else
	 {
	 	root[i]=modify(root[i-1],1,sz,getnum(h[back[i]]));
	 } 
  }
  for (int i=1;i<=q;i++)
  {
  	//cout<<1<<endl;
  	  int x=read(),y=read(),z=read();
  	  int faa = solve(x,y);
  	  //cout<<faa<<endl;
  	  //cout<<ymh[faa]<<" "<<faa<<" "<<val[faa]<<endl;
  	  if (ymh[faa]<z) cout<<-1<<"\n";
  	  else cout<<v[query(root[dfn[faa]],root[dfn[faa]+size[faa]-1],1,sz,z)-1]<<"\n";
  }
  return 0;
}