bzoj 3551

按照困难度升序排序
Kruskal重构树
这样一来一个点的子树中的所有困难值都小于改点的困难值
对于每次询问
倍增找出困难值最大且小于x的点
该点的子树中的第k大就是询问的答案
主席书维护区间k大

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>

using namespace std;
const int N = 1e5 + , M = 2e5 + ;

int n, m, Q;
int A[N << ], high[N << ], val[N << ];
struct Node {
    int u, v, hard;
} Edge[M * ];
struct Node_ {
    int v, nxt;
} G[M * ];
int fa[N << ];
int Root[N << ];
int W[M * ];
int head[N << ];
int Lson[M * ], Rson[M * ];
int now;
int tree[N << ], bef[N << ], lst[N << ], rst[N << ], Tree;
int N_;
int f[N << ][];
int Ans;
int Segjs;
int impjs;

#define gc getchar()
inline int read() {
    int x = ; char c = gc;
    while(c < '' || c > '') c = gc;
    while(c >= '' && c <= '') x = x *  + c - '', c = gc;
    return x;
}

inline bool Cmp(Node a, Node b) {
    return a.hard < b.hard;
}

int Get(int x) {
    return fa[x] == x ? x : fa[x] = Get(fa[x]);
}

inline void Add(int u, int v) {
    G[++ now].v = v;
    G[now].nxt = head[u];
    head[u] = now;
}

inline void Pre() {
    for(int i = ; i <= ; i ++) for(int j = ; j <= n *  - ; j ++) f[j][i] = f[f[j][i - ]][i - ];
}

inline void Fill(int x, int y) {
    Lson[x] = Lson[y], Rson[x] = Rson[y], W[x] = W[y];
}

inline int Imp_find(int u, int x) {
    for(int i = ; i >= ; i --) if(f[u][i] && val[f[u][i]] <= x) u = f[u][i];
    return u;
}

inline void Kruskal() {
    sort(Edge + , Edge + m + , Cmp);
    impjs = n;
    for(int i = ; i <= n * ; i ++) fa[i] = i;
    for(int i = ; i <= n * ; i ++) head[i] = -;
    for(int i = ; i <= m; i ++) {
        int fau = Get(Edge[i].u), fav = Get(Edge[i].v);
        if(fau != fav) {
            impjs ++;
            val[impjs] = Edge[i].hard;
            fa[fau] = fa[fav] = impjs;
            Add(impjs, fau), Add(fau, impjs), Add(impjs, fav), Add(fav, impjs);
        }
        if(impjs == n *  - ) break;
    }
}

void Dfs(int u, int fa) {
    if(u <= n) {
        lst[u] = rst[u] = ++ Tree;
        bef[Tree] = u;
    }
    else lst[u] = n;
    for(int i = head[u]; ~ i; i = G[i].nxt) {
        int v = G[i].v;
        if(v == fa) continue;
        f[v][] = u;
        Dfs(v, u);
        rst[u] = max(rst[u], rst[v]), lst[u] = min(lst[u], lst[v]);
    }
}

void Insert(int &rt, int l, int r, int x) {
    Fill(++ Segjs, rt);
    rt = Segjs;
    W[rt] ++;
    if(l == r) return ;
    int mid = (l + r) >> ;
    if(x <= mid) Insert(Lson[rt], l, mid, x);
    else Insert(Rson[rt], mid + , r, x);
}

void Sec_A(int jd1, int jd2, int l, int r, int k) {
    if(l == r) {Ans = l; return ;}
    if(W[jd2] - W[jd1] < k) {Ans = -; return ;}
    int mid = (l + r) >> ;
    if(W[Rson[jd2]] - W[Rson[jd1]] >= k) Sec_A(Rson[jd1], Rson[jd2], mid + , r, k);
    else Sec_A(Lson[jd1], Lson[jd2], l, mid, k - (W[Rson[jd2]] - W[Rson[jd1]]));
}

int main() {
    n = read(), m = read(), Q = read();
    for(int i = ; i <= n; i ++)
        A[i] = read(), high[i] = A[i];
    for(int i = ; i <= m; i ++) {
        int a = read(), b = read(), c = read();
        Edge[i] = (Node) {a, b, c};
    }
    sort(A + , A + n + );
    int a = unique(A + , A + n + ) - A - ;
    for(int i = ; i <= n; i ++)
        high[i] = lower_bound(A + , A + a + , high[i]) - A;
    Kruskal();
    Dfs(impjs, );
    Pre();
    for(int i = ; i <= n; i ++) {
        Root[i] = Root[i - ];
        Insert(Root[i], , n, high[bef[i]]);
    }
    for(; Q; Q --) {
        int v = read(), x = read(), k = read();
        if(Ans != -) v ^= Ans, x ^= Ans, k ^= Ans;
        int use = Imp_find(v, x);
        Sec_A(Root[lst[use] - ], Root[rst[use]], , n, k);
        if(Ans != -) Ans = A[Ans];
        printf("%d\n", Ans);
    }
    return ;
}