#include<iostream>

#include<stdio.h>

#include<string.h>

#include<vector>

#include<algorithm>

#define LL long long

#define rep(i,j,k) for(int i=j;i<=k;i++)

#define per(i,j,k) for(int i=j;i>=k;i--)

#define pb push_back

using namespace std;

const int maxx = ;

struct node{

   int l,r,cnt;

}tree[maxx*];

inline int MID(int l,int r){return (l+r)>>;};

int root[maxx*];

int a[maxx];

int ver[maxx*],Next[maxx*],head[maxx];

int tot,cnt,n,m;

int t=;

int fa[maxx],p[maxx][],deepth[maxx];

vector<int>v;

void add(int x,int y){

   ver[++tot]=y;Next[tot]=head[x];head[x]=tot;

   ver[++tot]=x;Next[tot]=head[y];head[y]=tot;

}

void update(int l,int r,int pre,int &now,int pos){

   now=++cnt;

   tree[now]=tree[pre];

   tree[now].cnt++;

   if (l==r)return;

   int mid=(l+r)>>;

   if (pos<=mid)

    update(l,mid,tree[pre].l,tree[now].l,pos);

   else

    update(mid+,r,tree[pre].r,tree[now].r,pos);

}

int query(int l,int r,int L,int R,int k,int lca,int flac){

   if (l==r)return l;

   int tmp=tree[tree[R].l].cnt+tree[tree[L].l].cnt-tree[tree[lca].l].cnt-tree[tree[flac].l].cnt;

   int mid=MID(l,r);

   if (k<=tmp)

     return query(l,mid,tree[L].l,tree[R].l,k,tree[lca].l,tree[flac].l);

   else

     return query(mid+,r,tree[L].r,tree[R].r,k-tmp,tree[lca].r,tree[flac].r);

}

void dfs(int u,int pre){

   fa[u]=pre;

   deepth[u]=deepth[pre]+;

   p[u][]=pre;

   update(,n,root[pre],root[u],a[u]);

   rep(i,,)p[u][i]=p[p[u][i-]][i-];

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

      int y=ver[i];

      if (y==pre)continue;

      dfs(y,u);

   }

}

int LCA(int x,int y){

   if (deepth[x]>deepth[y])swap(x,y);

   per(i,t,){

     if (deepth[p[y][i]]>=deepth[x])y=p[y][i];

   }

   if (x==y)return y;

   per(i,t,){

      if(p[x][i]!=p[y][i])x=p[x][i],y=p[y][i];

   }

   return p[x][];

}

int main(){

    while(~scanf("%d%d",&n,&m)){

        int uu,vv;

        memset(head,,sizeof(head));

        rep(i,,n){

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

          v.pb(a[i]);

        }

        tot=;

        cnt=;

        sort(v.begin(),v.end());

        v.erase(unique(v.begin(),v.end()),v.end());

        rep(i,,n-){

          scanf("%d%d",&uu,&vv);

          add(uu,vv);

        }

        rep(i,,n){

          a[i]=lower_bound(v.begin(),v.end(),a[i])-v.begin()+;

        }

        dfs(,);

        int k;

        while(m--){

            scanf("%d%d%d",&uu,&vv,&k);

            int lca=LCA(uu,vv);

            printf("%d\n",v[query(,n,root[uu],root[vv],k,root[lca],root[fa[lca]])-]);

        }

    }

   return ;

}