#include <cstdio>

 #include <iostream>

 #include <algorithm>

 #include <cstring>

 using namespace std;

 const int maxn = 1e5 + ;

 const int maxd = ;

 struct Edge{

     int v, next;

 }p[maxn << ];

 int head[maxn], e, d[maxn], f[maxn][maxd];

 //LCA

 void init(){

     memset(d, , sizeof(d));

     memset(f, , sizeof(f));

     memset(head, -, sizeof(head));

     e = ;

 }

 void addEdge(int u, int v){

     p[e].v = v; p[e].next = head[u]; head[u] = e++;

     swap(u, v);

     p[e].v = v; p[e].next = head[u]; head[u] = e++;

 }

 int lca(int u, int v){

     if (d[u] < d[v]) swap(u, v);

     int k = d[u] - d[v];

     for (int i = ; i < maxd;  ++i)

         if (( << i) & k) u = f[u][i];

     if (u == v) return u;

     for (int i = maxd - ; i >= ; --i){

         if (f[u][i] != f[v][i]){

             u = f[u][i];

             v = f[v][i];

         }

     }

     return f[u][];

 }

 //CMT

 int ls[maxn * ], rs[maxn * ], sum[maxn * ], T[maxn], tot, rt;

 int num[maxn], san[maxn], n, m; // 离散化前点数,离散化后点数

 void init_hash(){

     for (int i = ; i <= n; ++i) san[i] = num[i];

     sort(san + , san + n + );

     m = unique(san + , san + n + ) - san - ;

 }

 int hash(int x){

     return lower_bound(san + , san + m + , x) - san;

 }

 void build(int l, int r, int& rt){

     rt = ++ tot; sum[rt] = ;

     if (l == r) return;

     int mid = (l + r) >> ;

     build(l, mid, ls[rt]);

     build(mid + , r, rs[rt]);

 }

 void update(int last, int pos, int l, int r, int& rt){

     rt = ++ tot;

     ls[rt] = ls[last], rs[rt] = rs[last], sum[rt] = sum[last] + ;

     if (l == r) return ;

     int mid = (l + r) >> ;

     if (pos <= mid) update(ls[last], pos, l, mid, ls[rt]);

     else update(rs[last], pos, mid + , r, rs[rt]);

 }

 int query(int pos, int left_rt, int right_rt, int lca_rt, int l, int r, int k){

     if (l == r) return l;

     int mid = (l + r) >> ;

     int cnt = sum[ls[left_rt]] + sum[ls[right_rt]] -  * sum[ls[lca_rt]] + (pos >= l && pos <= mid);//注意lca为跟的时候

     if (k <= cnt) return query(pos, ls[left_rt], ls[right_rt], ls[lca_rt], l, mid, k);

     else return query(pos, rs[left_rt], rs[right_rt], rs[lca_rt], mid + , r, k - cnt);

 }

 //LCA && CMT

 void dfs(int u, int fa){

     f[u][] = fa;//注意

     d[u] = d[f[u][]] + ;

     update(T[fa], hash(num[u]), , m, T[u]);

     for (int i = ; i < maxd; ++i) f[u][i] = f[ f[u][i - ] ][i - ];

     for (int i = head[u]; ~i; i = p[i].next){

         if (p[i].v == fa) continue;

         dfs(p[i].v, u);

     }

 }

 int main(){

     int q, u, v, k;

     while (scanf("%d%d", &n, &q) == ){

         for (int i = ; i <= n; ++i) scanf("%d", &num[i]);

         init();

         init_hash();

         tot = ;

         for (int i = ; i < n; ++i){

             scanf("%d%d", &u, &v);

             addEdge(u, v);

         }

         build(, m, T[]);

         dfs(, );

         while (q--){

             scanf("%d%d%d", &u, &v, &k);

             printf("%d\n",san[query(hash(num[lca(u, v)]), T[u], T[v], T[lca(u, v)],, m, k)]);

         }

     }

     return ;

 }