#include <bits/stdc++.h>
using namespace std;

class HLDecomposition {
	vector<vector<int>> g;
	vector<int> vid, head, heavy, parent, depth;
public:
	vector<int> inv;
private:
	int dfs(int curr, int prev) {
		parent[curr] = prev;
		int sub = 1, max_sub = 0;
		for (int next : g[curr]) if (next != prev) {
			depth[next] = depth[curr] + 1;
			int sub_next = dfs(next, curr);
			sub += sub_next;
			if (max_sub < sub_next) max_sub = sub_next, heavy[curr] = next;
		}
		return sub;
	}
	void bfs() {
		int k = 0;
		queue<int> q({ 0 });
		while (!q.empty()) {
			int h = q.front(); q.pop();
			for (int i = h; i != -1; i = heavy[i]) {
				vid[i] = k++;
				inv[vid[i]] = i;
				head[i] = h;
				for (int j : g[i]) if (j != parent[i] && j != heavy[i]) q.push(j);
			}
		}
	}
public:
	HLDecomposition(int n)
		: g(n), vid(n, -1), head(n), heavy(n, -1), parent(n), depth(n), inv(n) {}

	void add(int u, int v) {
		g[u].push_back(v);
		g[v].push_back(u);
	}
	void build() {
		dfs(0, -1);
		bfs();
	}
	void for_each(int u, int v, function<void(int, int)> f) {
		if (vid[u] > vid[v]) swap(u, v);
		f(max(vid[head[v]], vid[u]), vid[v]);
		if (head[u] != head[v]) for_each(u, parent[head[v]], f);
	}
};

template <typename T>
class SegmentTree {
	const int n;
	vector<vector<T>> data;
	vector<T> merge(const vector<T>& l, const vector<T>& r) {
		int nl = l.size(), nr = r.size();
		vector<T> res(nl + nr);
		for (int i = 0, j = 0, k = 0; i < nl || j < nr; k++) {
			if (j == nr)
				res[k] = l[i++];
			else if (i == nl)
				res[k] = r[j++];
			else if (l[i] <= r[j])
				res[k] = l[i++];
			else
				res[k] = r[j++];
		}
		return res;
	}
	int size(int n) {
		int res;
		for (res = 1; res < n; res <<= 1);
		return res;
	}
	T sub(int l, int r, int node, int lb, int ub, T val) {
		if (ub <= l || r <= lb) return 0;
		if (l <= lb && ub <= r) return upper_bound(data[node].begin(), data[node].end(), val) - data[node].begin();
		return sub(l, r, node * 2, lb, (lb + ub) / 2, val) + sub(l, r, node * 2 + 1, (lb + ub) / 2, ub, val);
	}
public:
	SegmentTree(const vector<T>& data_) : n(size(data_.size())), data(n * 2) {
		for (int i = 0; i < (int)data_.size(); i++)
			data[i + n].push_back(data_[i]);
		for (int i = n - 1; i >= 0; i--)
			data[i] = merge(data[i * 2], data[i * 2 + 1]);
	}
	void Update(int p, T val) {
		p += n;
		data[p][0] = val;
		while (p >>= 1) data[p] = merge(data[p * 2], data[p * 2 + 1]);
	}
	void Add(int p, T val) {
		p += n;
		data[p][0] += val;
		while (p >>= 1) data[p] = merge(data[p * 2], data[p * 2 + 1]);
	}
	T Find(int l, int r, T val) {
		return sub(l, r + 1, 1, 0, n, val);
	}
};

int main()
{
	cin.sync_with_stdio(false);
	cin.tie(0);
	int N, Q;
	cin >> N >> Q;
	vector<int> W(N), base(N);
	for (int i = 0; i < N; i++) {
		cin >> W[i];
	}
	HLDecomposition hl(N);
	for (int i = 0, u, v; i < N - 1; i++) {
		cin >> u >> v; u--; v--;
		hl.add(u, v);
	}
	hl.build();
	for (int i = 0; i < N; i++) {
		base[i] = W[hl.inv[i]];
	}
	int v, w, l;
	SegmentTree<int> st(base);
	while (Q--) {
		cin >> v >> w >> l; v--; w--;
		int lb = 0, ub = 1000000000;
		while (lb + 1 < ub) {
			int c = lb + (ub - lb) / 2;
			int sum = 0;
			hl.for_each(v, w, [&](int ll, int rr) {
				sum += st.Find(ll, rr, c);
			});
			if (sum >= l) {
				ub = c;
			}
			else {
				lb = c;
			}
		}
		printf("%d\n", ub);
	}
	return 0;
}

Measured memory_bytes: 32200