bzoj3551[ONTAK2010]Peaks加强版 (dfs序+倍增+并查集+主席树）

Description

在Bytemountains有N座山峰，每座山峰有他的高度h_i。有些山峰之间有双向道路相连，共M条路径，每条路径有一个困难值，这个值越大表示越难走，现在有Q组询问，每组询问询问从点v开始只经过困难值小于等于x的路径所能到达的山峰中第k高的山峰，如果无解输出-1。

Input

第一行三个数N，M，Q。
第二行N个数，第i个数为h_i
接下来M行，每行3个数a b c，表示从a到b有一条困难值为c的双向路径。
接下来Q行，每行三个数v x k，表示一组询问。
Output
对于每组询问，输出一个整数表示答案。

Sample Input
10 11 4
1 2 3 4 5 6 7 8 9 10
1 4 4
2 5 3
9 8 2
7 8 10
7 1 4
6 7 1
6 4 8
2 1 5
10 8 10
3 4 7
3 4 6
1 5 2
1 5 6
1 5 8
8 9 2

Sample Output
6
10
9
-1

---

题外话：
这题是bzoj3545的强化版，关于bzoj3545的做法，我等蒟蒻只想到了用平衡树（或FHQtreap)+并查集搞一搞，不过只能离线做，对于这题要求的在线那是万万做不到的。
正题：
首先要知道最小生成树在本题的作用，最小生成树能够在每条边都最短的情况下让该图联通，然而本题还需要在某种结构上查找，于是我们在做最小生成树的时候，用并查集将每一个点变成叶子节点，用边权作为父节点来连接几个叶节点。
这就类似于重新建了棵树，而且我们是做最小生成树，那么每个作为子节点的权值必然小于等于父节点。于是我们用倍增在这棵树上快速找到最高的合法的V点，以V为根节点的子树必然都可以找到，用dfs序让这棵树能够序号连续，但是只有作为山峰的点才需要插值，作为边权的点就直接沿袭上一棵主席树即可。

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <string>
#include <cmath>
#define N 130000
int root[N*2],q[N*2],ls[N*18],rs[N*18],c[N*18];
int n,m,Q,wz[N],val[N*2],f[N*2],fa[N*2][18],tou[N*2],dd,top;
int st[N*2],ed[N*2],tot,ma[N*2][18];
bool vis[N];
struct aa{
    int len,x,y;
}dz[N*6];
struct pp{
    int va,pos;
}poi[N];
struct az{
    int p,next;
}da[N*4];
inline bool cmp(const aa a,const aa b){return a.len<b.len;}
inline bool cm(pp a,pp b){return a.va<b.va;}
int build(int l,int r){
    int rt=++tot;
    c[rt]=0;
    if (l==r)return rt;
    int mid=(l+r)/2;
    if (l<=mid)ls[rt]=build(l,mid);
    if (mid+1<=r)rs[rt]=build(mid+1,r);
    return rt;
}
int update(int rt,int pos){
    int tmp,rt1;tmp=rt1=++tot;
    int l=1;int r=n;
    c[rt1]=c[rt]+1;
    while (l<r){
        int mid=(l+r)/2;
        if (pos<=mid){
            ls[rt1]=++tot;rs[rt1]=rs[rt];
            rt1=ls[rt1];rt=ls[rt];
            r=mid;
        }else{
            rs[rt1]=++tot;ls[rt1]=ls[rt];
            rt1=rs[rt1];rt=rs[rt];
            l=mid+1;
        } 
        c[rt1]=c[rt]+1;
    }
    return tmp;
}
int query(int rt,int rt1,int l,int r,int pos){
    while (l<r){
        int mid=(l+r)/2;
        int num=c[ls[rt1]]-c[ls[rt]];
        if (pos<=num){
            rt1=ls[rt1];rt=ls[rt];
            r=mid;
        }else{
            pos-=num;
            rt1=rs[rt1];rt=rs[rt];
            l=mid+1;
        } 
    }
    return poi[l].va;
}
//-----------------------------------------主席树 
void add(int x,int y){
    da[++dd].p=y;da[dd].next=tou[x];tou[x]=dd;
}
//-----------------------------------------建边 
int find(int x){
    if (f[x]==x)return x;
    f[x]=find(f[x]);
    return f[x];
}
//-----------------------------------------并查集
int findd(int x,int va){
    for (int i=17;i>=0;i--)
      if (fa[x][i]&&ma[x][i]<=va)x=fa[x][i];
    return x;
}
void dfs(int x){
    q[++top]=x;vis[x]=1;
    for (int i=1;i<=17;i++){
        fa[x][i]=fa[fa[x][i-1]][i-1];
        ma[x][i]=std::max(ma[x][i-1],ma[fa[x][i-1]][i-1]);
        if (!fa[x][i])break;
    }
    for (int i=tou[x];i;i=da[i].next){
        fa[da[i].p][0]=x;
        ma[da[i].p][0]=val[x];
        dfs(da[i].p);
    }
    if(x>n)q[++top]=x;
}
//-----------------------------------------dfs序+倍增 
void tree_build(){
    int nod=n;
    for (int i=1;i<=2*n;i++)f[i]=i;
    for (int i=1;i<=m;i++){
        int fx=find(dz[i].x);
        int fy=find(dz[i].y);
        if (fx!=fy){
            f[fx]=f[fy]=++nod;
            val[nod]=dz[i].len;
            add(nod,fx);add(nod,fy);
            if (nod==2*n-1)break;
        }
    }
    for (int i=1;i<=n;i++)
      if (!vis[i])dfs(find(i));
    for (int i=1;i<=top;i++){
        int x=q[i];
        if (x<=n)root[i]=update(root[i-1],wz[x]);
        else{
            root[i]=root[i-1];
            if (!st[x])st[x]=i;
            else ed[x]=i;
        }
    }
}
void tree_solve(){
    int last;
    last=-1;
    for (int i=1;i<=Q;i++){
        int x,v,k;
        scanf("%d%d%d",&v,&x,&k);
        if (last!=-1)v=v^last,x=x^last,k=k^last;
        int nods=findd(v,x);
        if (c[root[ed[nods]]]-c[root[st[nods]]]<k)printf("-1\n"),last=-1;
        else {
            last=query(root[st[nods]],root[ed[nods]],1,n,c[root[ed[nods]]]-c[root[st[nods]]]+1-k);
            printf("%d\n",last);
        }
    }
}
//-----------------------------------------主程序 
int main(){
    scanf("%d%d%d",&n,&m,&Q);
    for (int i=1;i<=n;i++)scanf("%d",&poi[i].va),poi[i].pos=i;
    std::sort(poi+1,poi+n+1,cm);
    root[0]=build(1,n);
    for (int i=1;i<=n;i++)wz[poi[i].pos]=i;
    for (int i=1;i<=m;i++)
        scanf("%d%d%d",&dz[i].x,&dz[i].y,&dz[i].len);
    std::sort(dz+1,dz+m+1,cmp);
    tree_build();
    tree_solve();
    return 0;
}