[BZOJ3551][ONTAK2010]Peaks加强版

题目大意：
　　一个图上有$n(nle10^5)$个带权点，$m(mle5 imes10^5)$条带权边。有$q(qle5 imes10^5)$组询问，每次询问从点$v$出发，只经过权值小于等于$x$的边能到达的点中，权值第$k$大的点权。强制在线。

思路：
　　不强制在线时显然可以线段树合并。在线时需要建立Kruskal重构树，并对其DFS序建立主席树维护权值出现次数，每次询问结点权值小于等于$x$的虚点祖先所在的子树，求子树第$k$大值。

#include<cstdio>
#include<cctype>
#include<cstring>
#include<climits>
#include<algorithm>
#include<sys/mman.h>
#include<sys/stat.h>
class MMapInput {
    private:
        char *buf,*p;
        int size;
    public:
        MMapInput() {
            register int fd=fileno(stdin);
            struct stat sb;
            fstat(fd,&sb);
            size=sb.st_size;
            buf=reinterpret_cast<char*>(mmap(0,size,PROT_READ,MAP_PRIVATE,fileno(stdin),0));
            p=buf;
        }
        char getchar() {
            return (p==buf+size||*p==EOF)?EOF:*p++;
        }
};
MMapInput mmi;
inline int getint() {
    register char ch;
    while(!isdigit(ch=mmi.getchar()));
    register int x=ch^'0';
    while(isdigit(ch=mmi.getchar())) x=(((x<<2)+x)<<1)+(ch^'0');
    return x;
}
const int N=1e5+1,N2=N<<1,logN=18,logN2=18,M=5e5,M2=N2;
bool vis[N2];
int n,m,q,tmp[N],h[N2],val[N2]={INT_MAX},dep[N2],anc[N2][logN2],in[N2],out[N2],cnt,tot,sz;
struct Edge {
    int u,v,w;
    bool operator < (const Edge &another) const {
        return w<another.w;
    }
};
Edge e[M];
struct DisjointSet {
    int anc[N2];
    DisjointSet() {
        for(register int i=0;i<N2;i++) anc[i]=i;
    }
    int find(const int &x) {
        return x==anc[x]?x:anc[x]=find(anc[x]);
    }
    void merge(const int &x,const int &y) {
        anc[find(x)]=find(y);
    }
    bool same(const int &x,const int &y) {
        return find(x)==find(y);
    }
};
DisjointSet s;
struct Edge2 {
    int to,next;
};
Edge2 e2[M2];
inline void add_edge(const int &u,const int &v) {
    e2[sz]=(Edge2){v,h[u]};h[u]=sz++;
}
inline void kruskal() {
    tot=n;
    std::sort(&e[0],&e[m]);
    for(register int i=0;i<m;i++) {
        const int u=e[i].u,v=e[i].v,w=e[i].w;
        if(!s.same(u,v)) {
            val[++tot]=w;
            add_edge(tot,s.find(u));
            add_edge(tot,s.find(v));
            s.merge(s.find(u),tot);
            s.merge(s.find(v),tot); 
        }
    }
}
inline int log2(const float &x) {
    return ((unsigned&)x>>23&255)-127;
}
class SegmentTree {
    private:
        struct Node {
            int val,left,right;
        };
        Node node[N*logN];
        int sz,new_node(const int &p) {
            node[++sz]=node[p];
            return sz;
        }
        void push_up(const int &p) {
            node[p].val=node[node[p].left].val+node[node[p].right].val;
        }
    public:
        int root[N2*2];
        void modify(int &p,const int &b,const int &e,const int &x) {
            p=new_node(p);
            if(b==e) {
                node[p].val++;
                return;
            }
            const int mid=(b+e)>>1;
            if(x<=mid) modify(node[p].left,b,mid,x);
            if(x>mid) modify(node[p].right,mid+1,e,x);
            push_up(p);
        }
        int query(const int &p,const int &q,const int &b,const int &e,const int &k) {
            if(node[q].val-node[p].val<k) return 0;
            if(b==e) return b;
            const int mid=(b+e)>>1;
            if(node[node[q].right].val-node[node[p].right].val>=k) {
                return query(node[p].right,node[q].right,mid+1,e,k);
            } else {
                return query(node[p].left,node[q].left,b,mid,k-(node[node[q].right].val-node[node[p].right].val));
            }
        }
};
SegmentTree t;
void dfs(const int &x,const int &par) {
    vis[x]=true;
    dep[x]=dep[anc[x][0]=par]+1;
    for(register int i=1;i<=log2(dep[x]);i++) {
        anc[x][i]=anc[anc[x][i-1]][i-1];
    }
    in[x]=++cnt;
    t.root[in[x]]=t.root[in[x]-1];
    for(register int i=h[x];~i;i=e2[i].next) {
        const int &y=e2[i].to;
        dfs(y,x);
    }
    out[x]=++cnt;
    t.root[out[x]]=t.root[out[x]-1];
    if(x<=n) t.modify(t.root[out[x]],1,tmp[0],val[x]);
}
inline int find(int v,const int &x) {
    for(register int i=log2(dep[v]);~i;i--) {
        if(val[anc[v][i]]<=x) v=anc[v][i];
    }
    return v;
}
int main() {
    memset(h,-1,sizeof h);
    n=getint(),m=getint(),q=getint();
    for(register int i=1;i<=n;i++) {
        tmp[i]=val[i]=getint();
    }
    std::sort(&tmp[1],&tmp[n]+1);
    tmp[0]=std::unique(&tmp[1],&tmp[n]+1)-&tmp[1];
    for(register int i=1;i<=n;i++) {
        val[i]=std::lower_bound(&tmp[1],&tmp[tmp[0]]+1,val[i])-&tmp[0];
    }
    for(register int i=0;i<m;i++) {
        const int u=getint(),v=getint(),w=getint();
        e[i]=(Edge){u,v,w};
    }
    kruskal();
    for(register int i=1;i<=tot;i++) {
        if(!vis[i]) dfs(s.find(i),0);
    }
    for(register int i=0,ans=0;i<q;i++) {
        const int v=getint()^ans,x=getint()^ans,k=getint()^ans,p=find(v,x);
        ans=t.query(t.root[in[p]],t.root[out[p]],1,tmp[0],k);
        printf("%d
",ans?ans=tmp[ans]:-1); 
    }
    return 0;
}