【BZOJ 3551】[ONTAK2010] Peaks加强版 Kruskal重构树+树上倍增+主席树

这题真刺激......

I.关于Kruskal重构树，我只能开门了，不过补充一下那玩意还是一棵满二叉树。（看一下内容之前请先进门坐一坐）

II.原来只是用树上倍增求Lca，但其实树上倍增是一种方法，Lca只是他的一种应用，他可以搞各种树上问题，树上倍增一般都会用到f数组。

|||.我们跑出来dfs序就能在他的上面进行主席树了。

IV.别忘了离散。

V.他可能不连通，我一开始想到了，但是我觉得出题人可能会是好（S）人（B），但是......

#include <cstdio>
#include <algorithm>
#define N 150000
#define M 550000
using namespace std;
inline int read()
{
  register int sum=;
  register char ch=getchar();
  while(ch<''||ch>'')ch=getchar();
  while(ch>=''&&ch<=''){
    sum=(sum<<)+(sum<<)+ch-'';
    ch=getchar();
  }
  return sum;
}
int n,m,Q;
struct E{
  int x,y,z;
}e[M+];
int comp(const E a,const E b){
  return a.z<b.z;
}
struct Via{
  int to,next;
}c[M];
int head[M>>],t;
int h[N+],dfs[M>>],l[M>>],r[M>>],Time;
int len,Hash[N+];
struct Seg_Tree{
  Seg_Tree *ch[];
  int l,r,size;
}*root[M>>],*null;
int d[M>>][],f[M>>][],P[N+],fa[M>>];
int Comp(const int x,const int y){
  return h[x]>h[y];
}
//*********************Define***********************
inline Seg_Tree *New(int l,int r){
  register Seg_Tree *p=new Seg_Tree;
  p->l=l,p->r=r,p->size=,p->ch[]=p->ch[]=null;
  return p;
}
void ins(Seg_Tree *&p,Seg_Tree *last,int z,int y,int key)
{
  p=New(z,y),p->size=last->size,p->size++;
  if(p->l==p->r) return;
  p->ch[]=last->ch[],p->ch[]=last->ch[];
  if(key<=((z+y)>>))ins(p->ch[],last->ch[],z,((z+y)>>),key);
  else ins(p->ch[],last->ch[],((z+y)>>)+,y,key);
}
int query(Seg_Tree *a,Seg_Tree *b,int k,int z,int y)
{
  if(z==y)return z;
  if(a->ch[]->size-b->ch[]->size>=k)return query(a->ch[],b->ch[],k,z,(z+y)>>);
  else return query(a->ch[],b->ch[],k-(a->ch[]->size-b->ch[]->size),((z+y)>>)+,y);
}
//*********************Seg_Tree*********************
inline void add(int x,int y){
  c[++t].to=y;
  c[t].next=head[x];
  head[x]=t;
}
inline int find(int x){
  return x==fa[x]?x:(fa[x]=find(fa[x]));
}
inline int Max(int x,int y){
  return x>y?x:y;
}
void Dfs(int x){
  l[x]=++Time,dfs[Time]=x;
  for(register int i=;i<;i++)f[x][i]=f[f[x][i-]][i-];
  for(register int i=;i<;i++)d[x][i]=Max(d[x][i-],d[f[x][i-]][i-]);
  for(register int i=head[x];i;i=c[i].next)Dfs(c[i].to);
  r[x]=Time;
}
inline void Kruskal(){
  sort(e+,e+m+,comp);
  for(register int i=;i<=n+n;i++)fa[i]=i;
  for(register int i=,had=;had<n-&&i<=m;i++)
  if(find(e[i].x)!=find(e[i].y)){
    register int X=find(e[i].x),Y=find(e[i].y);
    had++,add(had+n,X),add(had+n,Y),d[X][]=d[Y][]=e[i].z;
    f[X][]=f[Y][]=fa[X]=fa[Y]=had+n;
  }
  for(register int i=;i<=n;i++)
    if(!l[find(i)])Dfs(find(i));
}
inline int get_root(int x,int lim)
{
  for(register int i=;i>=;i--)
    if(f[x][i]&&d[x][i]<=lim)
      x=f[x][i];
  return x;
}
//********************Kruskal************************
inline void HASH(){
  sort(P+,P+n+,Comp);
  for(register int i=;i<=n;i++)
    if(i==||h[P[i]]!=h[P[i-]])
      Hash[++len]=h[P[i]],h[P[i]]=len;
    else h[P[i]]=len;
}
//********************Hash***************************
inline void Init(){
  n=read(),m=read(),Q=read(),null=New(,),null->ch[]=null->ch[]=null,root[]=null;
  for(register int i=;i<=n;i++)h[i]=read(),P[i]=i;HASH();
  for(register int i=;i<=m;i++)e[i].x=read(),e[i].y=read(),e[i].z=read();Kruskal();
  for(register int i=;i<=Time;i++)
    if(dfs[i]<=n)  root[i]=null,ins(root[i],root[i-],,len,h[dfs[i]]);
    else root[i]=root[i-];
}
inline void Work(){
    register int v,x,k,ans=;
    while(Q--){
    v=read(),x=read(),k=read();
    register int Root=get_root(v,x);
    if(root[r[Root]]->size-root[l[Root]-]->size<k){
      puts("-1"),ans=;continue;
    }
    printf("%d\n",(ans=Hash[query(root[r[Root]],root[l[Root]-],k,,len)]));
  }
}
int main(){
  Init();
  Work();
  return ;
}