【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+7,inv2=(MOD+1)/2;
      //int p=1e6+3;
      //double eps=1e-6;
      int dx[4]={-1,1,0,0};
      int dy[4]={0,0,-1,1};

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

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

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

int f[N][17],g[N][17],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[20],tot,n,m,Q,cnt,len,num;


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

ll readll()
{
   ll v=0,f=1;
   char c=getchar();
   while(c<48||57<c) {if(c=='-') f=-1; c=getchar();}
   while(48<=c&&c<=57) v=(v<<3)+v+v+c-48,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]=1; q[++len]=u;
    int e=head[u];
    while(e)
    {
        int v=vet[e];
        if(!vis[v])
        {
            dep[v]=dep[u]+1;
            f[v][0]=u;
            g[v][0]=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,17,0) 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)>>1;
    if(x<=mid) update(l,mid,x,t[p1].l,t[p2].l);
     else update(mid+1,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)>>1;
    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+1,r,k-tmp,t[p1].r,t[p2].r);
}

void build()
{
    num=n;
    sort(a+1,a+m+1,cmp);
    tot=0;
    rep(i,1,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==2*n-1) break;
        }
    }
    len=0;
    rep(i,1,n)
     if(!vis[i]) dfs(dsu(i));
    rep(i,1,16)
     rep(j,1,num)
      if(dep[j]>=bin[i])
      {
          f[j][i]=f[f[j][i-1]][i-1];
          g[j][i]=max(g[j][i-1],g[f[j][i-1]][i-1]);
      }
    cnt=0;
    rep(i,1,len)
    {
        int u=q[i];
        if(u<=n) update(1,n,h[u],root[i-1],root[i]);
         else
         {
             root[i]=root[i-1];
             if(!st[u]) st[u]=i;
              else ed[u]=i;
         }
    }
}

void solve()
{
    int v,x,k;
    int lastans=0;
    rep(i,1,Q)
    {
        v=read(),x=read(),k=read();
        if(lastans!=-1) 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=-1;
         else lastans=d[query(1,n,t[R].s-t[L].s-k+1,L,R)];
        printf("%d\n",lastans);
    }
}

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