#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned ll
#define ui unsigned int
#define i128 __int128
#define lid (id << 1)
#define rid (id << 1 | 1)
const int N = 5e5+5;
#ifdef ONLINE_JUDGE
#define cin IO::InputHelper::get_instance()
#define cout IO::OutputHelper::get_instance()
#define INPUT_FILE ""
#define OUTPUT_FILE ""
namespace IO {
	using size_type = size_t;
	static constexpr size_type INPUT_BUFFER_SIZE = 1 << 16, OUTPUT_BUFFER_SIZE = 1 << 16, MAX_INTEGER_SIZE = 20, MAX_FLOAT_SIZE = 50;static constexpr char input_file[] = INPUT_FILE, output_file[] = OUTPUT_FILE;
	struct InputHelper {
		FILE *m_file_ptr;char m_buf[INPUT_BUFFER_SIZE], *m_end, *m_cursor;bool m_ok;
		InputHelper &set_bad() { return m_ok = false, *this; }
		template <size_type BlockSize>
		void _reserve() {size_type a = m_end - m_cursor;if (a >= BlockSize) return;memmove(m_buf, m_cursor, a), m_cursor = m_buf;size_type b = a + fread(m_buf + a, 1, INPUT_BUFFER_SIZE - a, m_file_ptr);if (b < INPUT_BUFFER_SIZE) m_end = m_buf + b, *m_end = EOF;}
		template <typename Tp, typename BinaryOperation>
		InputHelper &fill_integer(Tp &ret, BinaryOperation op) {if (!isdigit(*m_cursor)) return set_bad();ret = op(Tp(0), *m_cursor - '0');size_type len = 1;while (isdigit(*(m_cursor + len))) ret = op(ret * 10, *(m_cursor + len++) - '0');m_cursor += len;return *this;}
		explicit InputHelper(const char *inputFileName) : m_ok(true), m_cursor(m_buf + INPUT_BUFFER_SIZE), m_end(m_buf + INPUT_BUFFER_SIZE) { m_file_ptr = *inputFileName ? fopen(inputFileName, "rt") : stdin; }
		~InputHelper() { fclose(m_file_ptr); }
		static InputHelper &get_instance() {static InputHelper s_obj(input_file);return s_obj;}
		static bool is_blank(char c) { return c == ' ' || c == '\t' || c == '\n' || c == '\r'; }static bool is_endline(char c) { return c == '\n' || c == EOF; }
		const char &getchar_checked() {_reserve<1>();return *m_cursor;}const char &getchar_unchecked() const { return *m_cursor; }
		void next() { ++m_cursor; }
		template <typename Tp, typename std::enable_if<std::is_signed<Tp>::value & std::is_integral<Tp>::value>::type * = nullptr>
		InputHelper &operator>>(Tp &num) {while (is_blank(getchar_checked())) next();_reserve<MAX_INTEGER_SIZE>();if (getchar_unchecked() != '-') return fill_integer(num, std::plus<Tp>());next();return fill_integer(num, std::minus<Tp>());}
		template <typename Tp, typename std::enable_if<std::is_unsigned<Tp>::value & std::is_integral<Tp>::value>::type * = nullptr>
		InputHelper &operator>>(Tp &num) {while (is_blank(getchar_checked())) next();_reserve<MAX_INTEGER_SIZE>();return fill_integer(num, std::plus<Tp>());}
		template <typename Tp, typename std::enable_if<std::is_floating_point<Tp>::value>::type * = nullptr>
		InputHelper &operator>>(Tp &num) {
			bool neg = false, integer = false, decimal = false;while (is_blank(getchar_checked())) next();_reserve<MAX_FLOAT_SIZE>();
			if (getchar_unchecked() == '-') {neg = true;next();}if (!isdigit(getchar_unchecked()) && getchar_unchecked() != '.') return set_bad();
			if (isdigit(getchar_unchecked())) {integer = true;num = getchar_unchecked() - '0';while (next(), isdigit(getchar_unchecked())) num = num * 10 + (getchar_unchecked() - '0');}
			if (getchar_unchecked() == '.') if (next(), isdigit(getchar_unchecked())) {if (!integer) num = 0;decimal = true;Tp unit = 0.1;num += unit * (getchar_unchecked() - '0');while (next(), isdigit(getchar_unchecked())) num += (unit *= 0.1) * (getchar_unchecked() - '0');}
			if (!integer && !decimal) return set_bad();if (neg) num = -num;return *this;
		}
		InputHelper &operator>>(char &c) {while (is_blank(getchar_checked())) next();if (getchar_checked() == EOF) return set_bad();c = getchar_checked(), next();return *this;}
		InputHelper &operator>>(std::string &s) {while (is_blank(getchar_checked())) next();if (getchar_checked() == EOF) return set_bad();s.clear();do {s += getchar_checked();next();} while (!is_blank(getchar_checked()) && getchar_unchecked() != EOF);return *this;}
		explicit operator bool() { return m_ok; }
	};
	struct OutputHelper {
		FILE *m_file_ptr = nullptr;char m_buf[OUTPUT_BUFFER_SIZE], *m_end, *m_cursor;char m_temp_buf[MAX_FLOAT_SIZE], *m_temp_buf_cursor, *m_temp_buf_dot;uint64_t m_float_reserve, m_float_ratio;
		void _write() { fwrite(m_buf, 1, m_cursor - m_buf, m_file_ptr), m_cursor = m_buf; }
		template <size_type BlockSize> void _reserve() {size_type a = m_end - m_cursor;if (a >= BlockSize) return;_write();}
		OutputHelper(const char *outputFileName, size_type prec = 6) : m_cursor(m_buf), m_end(m_buf + OUTPUT_BUFFER_SIZE), m_temp_buf_cursor(m_temp_buf) { m_file_ptr = *outputFileName ? fopen(outputFileName, "wt") : stdout, precision(prec); }
		static OutputHelper &get_instance() {static OutputHelper s_obj(output_file);return s_obj;}
		~OutputHelper() { flush(), fclose(m_file_ptr); }
		void precision(size_type prec) { m_float_reserve = prec, m_float_ratio = uint64_t(std::pow(10, prec)), m_temp_buf_dot = m_temp_buf + prec; }
		OutputHelper &flush() { return _write(), fflush(m_file_ptr), *this; }
		void putchar(const char &c) {if (m_cursor == m_end) _write();*m_cursor++ = c;}
		template <typename Tp, typename std::enable_if<std::is_signed<Tp>::value & std::is_integral<Tp>::value>::type * = nullptr>
		OutputHelper &operator<<(Tp ret) {_reserve<MAX_INTEGER_SIZE>();size_type len = 0;if (ret >= 0) do *(m_cursor + len++) = '0' + ret % 10, ret /= 10;while (ret);else {putchar('-');do *(m_cursor + len++) = '0' - ret % 10, ret /= 10;while (ret);}for (size_type i = 0, j = len - 1; i < j;) std::swap(*(m_cursor + i++), *(m_cursor + j--));m_cursor += len;return *this;}
		template <typename Tp, typename std::enable_if<std::is_unsigned<Tp>::value & std::is_integral<Tp>::value>::type * = nullptr>
		OutputHelper &operator<<(Tp ret) {_reserve<MAX_INTEGER_SIZE>();size_type len = 0;do *(m_cursor + len++) = '0' + ret % 10, ret /= 10;while (ret);for (size_type i = 0, j = len - 1; i < j;) std::swap(*(m_cursor + i++), *(m_cursor + j--));m_cursor += len;return *this;}
		template <typename Tp, typename std::enable_if<std::is_floating_point<Tp>::value>::type * = nullptr>
		OutputHelper &operator<<(Tp ret) {
			if (ret < 0) {putchar('-');return *this << -ret;}ret *= m_float_ratio;uint64_t integer = ret;if (ret - integer >= 0.4999999999) integer++;do {*m_temp_buf_cursor++ = '0' + integer % 10;integer /= 10;} while (integer);
			if (m_temp_buf_cursor > m_temp_buf_dot) {do putchar(*--m_temp_buf_cursor);while (m_temp_buf_cursor > m_temp_buf_dot);putchar('.');}else {putchar('0'), putchar('.');for (size_type i = m_temp_buf_dot - m_temp_buf_cursor; i--;) putchar('0');}
			do putchar(*--m_temp_buf_cursor);while (m_temp_buf_cursor > m_temp_buf);
			return *this;
		}
		OutputHelper &operator<<(const char &ret) {putchar(ret);return *this;}
		OutputHelper &operator<<(const char *ret) {while (*ret) putchar(*ret++);return *this;}
		OutputHelper &operator<<(const std::string &ret) { return *this << ret.data(); }
	};
	InputHelper &getline(InputHelper &ih, std::string &line) {line.clear();if (ih.getchar_checked() == EOF) return ih.set_bad();while (!InputHelper::is_endline(ih.getchar_checked())) line += ih.getchar_unchecked(), ih.next();if (ih.getchar_unchecked() != EOF) ih.next();return ih;}
}using IO::getline;
#endif
template<uint32_t P>
struct ModInt32{
	using mod_type = uint32_t;
	using mint = ModInt32;
	mod_type val;
	ModInt32(mod_type vala = 0) : val(vala >= P ? vala - P : vala) {}
	static inline mint raw(mod_type val){mint res;res.val = val;return res;}
	inline mint pow(uint64_t b){mod_type res = 1, a = val;while (b){if (b & 1) res = uint64_t(res) * a % P;a = uint64_t(a) * a % P;b >>= 1;}return res;}
	inline mint inv(){return pow(P - 2);}
	inline mint &operator ++(){if (++val == P) val = 0;return *this;}
	inline mint &operator --(){if (!val) val = P;return *this;}
	inline mint &operator +=(const mint &b){if ((val += b.val) >= P) val -= P;return *this;}
	inline mint &operator -=(const mint &b){if ((val += P - b.val) >= P) val -= P;return *this;}
	inline mint &operator *=(const mint &b){val = uint64_t(val) * b.val % P;return *this;}
	inline mint operator +(const mint &b){return mint(*this) += b;}
	inline mint operator -(const mint &b){return mint(*this) -= b;}
	inline mint operator *(const mint &b){return mint(*this) *= b;}
	inline bool operator ==(const mint &b){return val == b.val;}
	inline bool operator !=(const mint &b){return val != b.val;}
	inline bool operator <(const mint &b){return val < b.val;}
	inline bool operator <=(const mint &b){return val < b.val;}
	inline bool operator >(const mint &b){return val > b.bal;}
	inline bool operator >=(const mint &b){return val >= b.val;}
};
template <typename Istream, uint32_t P>
Istream &operator>>(Istream &is, ModInt32<P> &x) { return is >> x.val; }
template <typename Ostream, uint32_t P>
Ostream &operator<<(Ostream &os, const ModInt32<P> &x) { return os << x.val; }
namespace tianyu{
	int n, q;
	pair<int, int> a[N];
	typedef pair<int, int> pii;
	vector<pii> G[N];
	int st[20][N], dfn[N], dep[N], tot;
	ll dis[N];
	void dfs(int u, int f){
		dep[u] = dep[st[0][dfn[u] = ++tot] = f] + 1;
		for (auto i : G[u]){
			int v = i.first, w = i.second;
			if (v == f) continue;
			dis[v] = dis[u] + w;
			dfs(v, u);
		}
	}
	inline void init_st(){
		int lgg = __lg(n);
		for (int j = 1;j <= lgg;j++){
			for (int i = 1;i + (1 << j) - 1 <= n;i++){
                int x = st[j - 1][i], y = st[j - 1][i + (1 << (j - 1))];
				st[j][i] = dep[x] < dep[y] ? x : y;
			}
		}
	}
	inline int glca(int x, int y){
		if (x == y) return x;
		if ((x = dfn[x]) > (y = dfn[y])) swap(x, y);
		short s = __lg(y - x);
		x = st[s][x + 1], y = st[s][y - (1 << s) + 1];
		return dep[x] < dep[y] ? x : y;
	}
	inline ll gdis(int x, int y){
		return dis[x] + dis[y] - (dis[glca(x, y)] << 1);
	}
	int nod[N][2];
	void awa(){
		cin >> n >> q;
		for (int i = 1;i <= n;i++){
			cin >> a[i].first;
			a[i].second = i;
		}sort(a + 1, a + 1 + n);
		for (int i = 1;i < n;i++){
			int u, v, w;
			cin >> u >> v >> w;
			G[u].emplace_back(v, w);
			G[v].emplace_back(u, w);
		}
		if(a[1].first != 0){
			while (q--){
				cout << "0\n";
			}
			return;
		}
		nod[1][0] = nod[1][1] = a[1].second;
		dfs(a[1].second, 0);
		init_st();
		int mex = 1;
		for (int i = 2;i <= n;i++){
			if (a[i].first != i - 1){
				break;
			}
			mex = i;
			ll zhij = gdis(nod[i][0] = nod[i - 1][0], nod[i][1] = nod[i - 1][1]);
			ll x = gdis(a[i].second, nod[i][0]);
			ll y = gdis(a[i].second, nod[i][1]);
			if (x <= zhij && y <= zhij) continue;
			nod[i][x > y] = a[i].second;
		}
		while (q--){
			int x;
			ll k;
			cin >> x >> k;
			if (gdis(x, a[mex].first) <= k && gdis(x, a[mex].second) <= k){
				cout << mex << '\n';
				continue;
			}
			if (gdis(x, a[1].second) > k){
				cout << "0\n";
				continue;
			}
			int l = 0, r = mex - 1, ans = mex;
			while (l <= r){
				int mid = (l + r) >> 1;
				if (gdis(x, nod[mid][0]) <= k && gdis(x, nod[mid][1]) <= k){
					l = (ans = mid) + 1;
				}else r = mid - 1;
			}cout << ans << '\n';
		}
	}
}
signed main(){
	tianyu::awa();
	return 0;
}