//

 //  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 =  + ;

 const int M = ;

 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][],depth[M];

 void addEdge(int u, int v){

     to[e] = v;

     nxt[e] = head[u];

     head[u] = e++;

 }

 //离散化，离散化后有多少个点，线段树的区间就是多大

 void initHash(){

     sort(b+,b+n+);

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

 }

 int hs(int x){

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

 }

 int build(int l, int r){

     int root = total++;

     c[root] = ;

     if(l!=r){

         int mid = (l+r)>>;

         lson[root] = build(l,mid);

         rson[root] = build(mid+,r);

     }

     return root;

 }

 int update(int root, int pos, int val){

     int newRoot = total++,tmp = newRoot;

     c[newRoot] = c[root] + val;

     int l =, r = m;

     while(l<r){

         int mid = (l+r)>>;

         if(pos<=mid){

             r = mid;

             lson[newRoot] = total++;

             rson[newRoot] = rson[root];

             newRoot = lson[newRoot];

             root = lson[root];

         }

         else{

             l = mid + ;

             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][] = f;

     depth[u] = dep;

     for(int i=head[u]; i+;i=nxt[i]){

         int v = to[i];

         if(v==f)continue;

         t[++dfs_clock] = update(iid[u],hs(a[v]),);

         iid[v] = t[dfs_clock];

         dfs(v,u,dep+);

     }

 }

 int query(int urt, int vrt, int lcart, int frt, int k){

     int l = , r = m;

     //当l==r,即区间的长度只有1时，那么该区间所对应的值就是第k小了

     while(l<r){

         int mid = (l+r)>>;

         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+;

             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=;k+<; ++k){

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

             if(fa[v][k]<)

                 fa[v][k+] = -;

             else

                 fa[v][k+] = 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=;i>=;--i)

         if(tmp &(<<i))

         u = fa[u][i];

     if(u==v) return u;

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

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

             u = fa[u][i];

             v = fa[v][i];

         }

     }

     return fa[u][];

 }

 int main(int argc, const char * argv[]) {

     int u,v,k;

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

         total = dfs_clock = ;

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

             scanf("%d",&a[i]);

             b[i] = a[i];

         }

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

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

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

             addEdge(u,v);

             addEdge(v,u);

         }

         addEdge(,);

         addEdge(,);

         initHash();

         iid[] = t[] = build(,m);

         memset(fa,-,sizeof(fa));

         dfs(,,);

         init();

         while(q--){

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

             int lc = lca(u,v);

             int f = fa[lc][];

             printf("%d\n",b[query(iid[u],iid[v],iid[lc],iid[f],k)]);

         }

     }

     return ;

 }