【BZOJ3545&BZOJ3551】Peaks（kruskal重构树，主席树，dfs序）

题意：在Bytemountains有N座山峰，每座山峰有他的高度h_i。

有些山峰之间有双向道路相连，共M条路径，每条路径有一个困难值，这个值越大表示越难走，

现在有Q组询问，每组询问询问从点v开始只经过困难值小于等于x的路径所能到达的山峰中第k高的山峰，如果无解输出-1。

N<=10^5, M,Q<=5*10^5，h_i,c,x<=10^9。

强制在线

思路：考虑按照最小生成树的过程，维护联通块能走到的所有权值的个数，可以用线段树合并

kruskal重构树是类似用kruskal计算最小生成树的过程，但每次合并两个点x,y时不是直接连边，而是新建一个点T，分别链接T和x，y，T的点权为(x,y)的边权

这样生成的树最多有2*n-1个点，而且有以下性质：

1.从某个点v出发，能走到的点一定在v向上走直到点权>u的点y，这个点u的子树中

2.是二叉树

3.按最小生成树生成是一个大根堆

4.任意两点路径上的最大值是lca的点权

预处理之后变成查询静态子树k大，dfs序+主席树即可

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 typedef unsigned int uint;
 typedef unsigned long long ull;
 typedef long double ld;
 typedef pair<int,int> PII;
 typedef pair<ll,int> Pli;
 typedef pair<ll,ll> Pll;
 typedef vector<int> VI;
 typedef vector<PII> VII;
 typedef pair<ll,ll>P;
 #define N  200000+10
 #define M  400000+10
 #define INF 1e9
 #define fi first
 #define se second
 #define MP make_pair
 #define pb push_back
 #define pi acos(-1)
 #define mem(a,b) memset(a,b,sizeof(a))
 #define rep(i,a,b) for(int i=(int)a;i<=(int)b;i++)
 #define per(i,a,b) for(int i=(int)a;i>=(int)b;i--)
 #define lowbit(x) x&(-x)
 #define Rand (rand()*(1<<16)+rand())
 #define id(x) ((x)<=B?(x):m-n/(x)+1)
 #define ls p<<1
 #define rs p<<1|1
 #define fors(i) for(auto i:e[x]) if(i!=p)

 const int MOD=1e9+,inv2=(MOD+)/;
       //int p=1e6+3;
       //double eps=1e-6;
       int dx[]={-,,,};
       int dy[]={,,-,};

 struct edge
 {
     int x,y,z;
 }a[];

 bool cmp(edge a,edge b)
 {
     return a.z<b.z;
 }

 struct node
 {
     int l,r,s;
 }t[];

 int f[N][],g[N][],head[N],vet[M],nxt[M],val[M],st[N],ed[N],
     q[M],vis[N],fa[N],dep[N],h[N],d[N],root[M],bin[],tot,n,m,Q,cnt,len,num;

 int read()
 {
    int v=,f=;
    char c=getchar();
    while(c<||<c) {if(c=='-') f=-; c=getchar();}
    while(<=c&&c<=) v=(v<<)+v+v+c-,c=getchar();
    return v*f;
 }

 ll readll()
 {
    ll v=,f=;
    char c=getchar();
    while(c<||<c) {if(c=='-') f=-; c=getchar();}
    while(<=c&&c<=) v=(v<<)+v+v+c-,c=getchar();
    return v*f;
 }

 void add(int a,int b)
 {
     nxt[++tot]=head[a];
     vet[tot]=b;
     head[a]=tot;
 }

 void dfs(int u)
 {
     vis[u]=; q[++len]=u;
     int e=head[u];
     while(e)
     {
         int v=vet[e];
         if(!vis[v])
         {
             dep[v]=dep[u]+;
             f[v][]=u;
             g[v][]=val[u];
             dfs(v);
         }
         e=nxt[e];
     }
     if(u>n) q[++len]=u;
 }

 int dsu(int k)
 {
     if(fa[k]!=k) fa[k]=dsu(fa[k]);
     return fa[k];
 }

 int calc(int u,int x)
 {
     per(i,,) if(dep[u]>=bin[i]&&g[u][i]<=x) u=f[u][i];
     return u;
 }

 void update(int l,int r,int x,int p1,int &p2)
 {
     t[p2=++cnt]=t[p1];
     t[p2].s++;
     if(l==r) return;
     int mid=(l+r)>>;
     if(x<=mid) update(l,mid,x,t[p1].l,t[p2].l);
      else update(mid+,r,x,t[p1].r,t[p2].r);
 }

 int query(int l,int r,int k,int p1,int p2)
 {
     if(l==r) return l;
     int mid=(l+r)>>;
     int tmp=t[t[p2].l].s-t[t[p1].l].s;
     if(tmp>=k) return query(l,mid,k,t[p1].l,t[p2].l);
      else return query(mid+,r,k-tmp,t[p1].r,t[p2].r);
 }

 void build()
 {
     num=n;
     sort(a+,a+m+,cmp);
     tot=;
     rep(i,,m)
     {
         int p=dsu(a[i].x),q=dsu(a[i].y);
         if(p!=q)
         {
             num++;
             fa[p]=fa[q]=num;
             val[num]=a[i].z;
             add(num,q);
             add(num,p);
             if(num==*n-) break;
         }
     }
     len=;
     rep(i,,n)
      if(!vis[i]) dfs(dsu(i));
     rep(i,,)
      rep(j,,num)
       if(dep[j]>=bin[i])
       {
           f[j][i]=f[f[j][i-]][i-];
           g[j][i]=max(g[j][i-],g[f[j][i-]][i-]);
       }
     cnt=;
     rep(i,,len)
     {
         int u=q[i];
         if(u<=n) update(,n,h[u],root[i-],root[i]);
          else
          {
              root[i]=root[i-];
              if(!st[u]) st[u]=i;
               else ed[u]=i;
          }
     }
 }

 void solve()
 {
     int v,x,k;
     int lastans=;
     rep(i,,Q)
     {
         v=read(),x=read(),k=read();
         if(lastans!=-) v^=lastans,x^=lastans,k^=lastans;
         int u=calc(v,x);
         int L=root[st[u]],R=root[ed[u]];
         if(t[R].s-t[L].s<k) lastans=-;
          else lastans=d[query(,n,t[R].s-t[L].s-k+,L,R)];
         printf("%d\n",lastans);
     }
 }

 int main()
 {
     bin[]=;
     rep(i,,) bin[i]=bin[i-]<<;
     n=read(),m=read(),Q=read();
     rep(i,,n) h[i]=read(),d[i]=h[i];
     sort(d+,d+n+);
     rep(i,,n) h[i]=lower_bound(d+,d+n+,h[i])-d;
     rep(i,,*n) fa[i]=i;
     rep(i,,m)
     {
         a[i].x=read();
         a[i].y=read();
         a[i].z=read();
     }
     build();
     solve();
     return ;
 }