树上第k小，可持久化线段树+倍增lca

给定一颗树，树的每个结点都有权值，

有q个询问，每个询问是 u v k ,表示u到v路径上第k小的权值是多少。

每个结点所表示的线段树，是父亲结点的线段树添加该结点的权值之后形成的新的线段树

c[root] 表示根为root的子树添加了多少个结点。

那么c[lson[u]] + c[lson[v]] - c[lson[lca(u,v)]] - c[lson[fa[lca(u,v)]]]  >=k ,那么说明左子树添加了k个以上的结点，说明第k小的值在左子树

否则就在右子树。

//
//  main.cpp
//  函数式线段树
//
//  Created by whoami on 15/9/21.
//  Copyright (c) 2015年 whoami. All rights reserved.
//

#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <string.h>
using namespace std;
const int N = 3000000 + 10;
const int M = 200000;
int t[N],lson[N],rson[N],c[N],total;
int a[M],b[M];
int n,m,q;
int head[M],nxt[M],to[M],e;
int dfs_clock,iid[M];
int fa[M][30],depth[M];
void addEdge(int u, int v){
    to[e] = v;
    nxt[e] = head[u];
    head[u] = e++;
}

//离散化，离散化后有多少个点，线段树的区间就是多大
void initHash(){
    sort(b+1,b+n+1);
    m = unique(b+1,b+n+1) - b - 1;
}
int hs(int x){
    return lower_bound(b+1,b+m+1,x)-b;
}

int build(int l, int r){
    int root = total++;
    c[root] = 0;
    if(l!=r){
        int mid = (l+r)>>1;
        lson[root] = build(l,mid);
        rson[root] = build(mid+1,r);
    }
    return root;
}
int update(int root, int pos, int val){
    int newRoot = total++,tmp = newRoot;
    c[newRoot] = c[root] + val;
    int l =1, r = m;
    while(l<r){
        int mid = (l+r)>>1;
        if(pos<=mid){
            r = mid;
            lson[newRoot] = total++;
            rson[newRoot] = rson[root];
            newRoot = lson[newRoot];
            root = lson[root];
        }
        else{
            l = mid + 1;
            lson[newRoot] = lson[root];
            rson[newRoot] = total++;
            newRoot = rson[newRoot];
            root = rson[root];
        }
        c[newRoot] = c[root] + val;
    }
    return tmp;
}
void dfs(int u, int f, int dep){
    fa[u][0] = f;
    depth[u] = dep;

    for(int i=head[u]; i+1;i=nxt[i]){
        int v = to[i];
        if(v==f)continue;
        t[++dfs_clock] = update(iid[u],hs(a[v]),1);
        iid[v] = t[dfs_clock];
        dfs(v,u,dep+1);
    }
}

int query(int urt, int vrt, int lcart, int frt, int k){
    int l = 1, r = m;
    //当l==r,即区间的长度只有1时，那么该区间所对应的值就是第k小了
    while(l<r){
        int mid = (l+r)>>1;
        if(c[lson[urt]] + c[lson[vrt]] - c[lson[frt]]-c[lson[lcart]]>=k){
            r = mid;
            urt = lson[urt];
            vrt = lson[vrt];
            frt = lson[frt];
            lcart = lson[lcart];
        }
        else
        {
            l = mid+1;
            k -= c[lson[urt]] + c[lson[vrt]] - c[lson[frt]]-c[lson[lcart]];
            urt = rson[urt];
            vrt = rson[vrt];
            frt = rson[frt];
            lcart = rson[lcart];
        }
    }
    return l;
}
void init() {
    for(int k=0;k+1<25; ++k){
        for(int v = 0;v<=n;++v){
            if(fa[v][k]<0)
                fa[v][k+1] = -1;
            else
                fa[v][k+1] = fa[fa[v][k]][k];
        }
    }
}

int lca(int u, int  v){
    if(depth[u] < depth[v])
        swap(u,v);

    int tmp = depth[u] - depth[v];
    for(int i=25;i>=0;--i)
        if(tmp &(1<<i))
        u = fa[u][i];
    if(u==v) return u;
    for(int i=25;i>=0;--i){
        if(fa[u][i]!=fa[v][i]){
            u = fa[u][i];
            v = fa[v][i];
        }
    }
    return fa[u][0];

}
int main(int argc, const char * argv[]) {
    int u,v,k;
    while(scanf("%d%d",&n,&q)!=EOF){
        total = dfs_clock = 0;
        for(int i=1;i<=n;++i){
            scanf("%d",&a[i]);
            b[i] = a[i];
        }
        memset(head,-1,sizeof(head));
        for(int i=1;i<n;++i){
            scanf("%d%d",&u,&v);
            addEdge(u,v);
            addEdge(v,u);
        }
        addEdge(0,1);
        addEdge(1,0);
        initHash();
        iid[0] = t[0] = build(1,m);
        memset(fa,-1,sizeof(fa));
        dfs(0,0,1);

        init();
        while(q--){
            scanf("%d%d%d",&u,&v,&k);
            int lc = lca(u,v);
            int f = fa[lc][0];
            printf("%d
",b[query(iid[u],iid[v],iid[lc],iid[f],k)]);
        }
    }

    return 0;
}