#include <bits/stdc++.h>

using namespace std;

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

template<class T>
struct RMQ {
	vector<vector<T>> jmp;
	RMQ(const vector<T>& V) : jmp(1, V) {
		for (int pw = 1, k = 1; pw * 2 <= sz(V); pw *= 2, ++k) {
			jmp.emplace_back(sz(V) - pw * 2 + 1);
			rep(j,0,sz(jmp[k]))
				jmp[k][j] = min(jmp[k - 1][j], jmp[k - 1][j + pw]);
		}
	}
	T query(int a, int b) {
		assert(a < b); // or return inf if a == b
		int dep = 31 - __builtin_clz(b - a);
		return min(jmp[dep][a], jmp[dep][b - (1 << dep)]);
	}
};

typedef int int2;
#define int long long
#define pi pair<int, int>
#define vi vector<int>
#define vii vector<vector<int>>
#define vpi vector<pi>
#define lep(i,l,r) for(int i=l;i<=r;++i)
#define rep(i,r,l) for(int i=r;i>=l;--i)
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define f first
#define s second
const int inf = 1e18;

int t;



int2 main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    int n, q;
    cin >> n >> q;
    vector<int> a(n+1);
    lep(i,1,n) {
        cin >> a[i];
    }
    vector<vector<pi>> adj(n+1);
    vector<int> depth(n+1);
    lep(i,1,n-1) {
        int u, v, l;
        cin >> u >> v >> l;
        adj[u].pb({v, l});
        adj[v].pb({u, l});
    }
    int T = 0;
    vector<int> tin(n+1);
    vector<int> path, times;
    auto dfs1 = [&](auto &self, int u, int p) -> void {
        tin[u] = T++;
        for (pi pr: adj[u]) {
            int v = pr.f;
            int l = pr.s;
            if (v != p) {
                times.pb(tin[u]);
                path.pb(u);
                depth[v] = depth[u] + l;
                self(self, v, u);
            }
        }
    };

    dfs1(dfs1, 1, 0);

    RMQ<int> rmq(times);
    auto get_lca = [&](int u, int v) -> int {
        if (tin[u] > tin[v]) swap(u, v);
        if (u == v) return u;
        return path[rmq.query(tin[u], tin[v])];
    };

    auto get_dist = [&](int u, int v) -> int {
        return depth[u] + depth[v] - 2 * depth[get_lca(u, v)];
    };

    vector<pi> elts;
    lep(i,1,n) {
        elts.pb({a[i], i});
    }
    sort(elts.begin(), elts.end());
    vector<pi> diams;
    diams.pb({elts[0].s, elts[0].s});
    // lep(i,1,3) {
    //     lep(j,1,3) {
    //         cout << get_dist(i,j) << " ";
    //     }
    //     cout << "\n";
    // }
    // cout << "\n";
    lep(i,1,n-1) {
        int val = elts[i].f;
        int where = elts[i].s;
        auto [u, v] = diams.back();
        // cout << "u: " << u << ", v: " << v << "\n";
        int diam = get_dist(u, v);
        if (get_dist(where, v) > diam) {
            u = where;
        } else if (get_dist(where, u) > diam) {
            v = where;
        }
        diams.pb({u, v});
    }
    // for (auto [u, v]: diams) {
    //     cout << "u: " << u << ", v: " << v << ", dist: " << get_dist(u, v) << "\n";
    // }
    vector<int> ans(q+1);
    lep(qq,1,q) {
        int u, d;
        cin >> u >> d;
        // binary search on answer
        int q_ans = -1;
        int ln = 20;
        rep(i,20,0) {
            int idx = q_ans + (1<<i);
            if (idx < (int)diams.size() and max(get_dist(u, diams[idx].f), get_dist(u, diams[idx].s)) <= d) {
                q_ans = idx;
            }
        }
        // cout << "qq: " << qq << ", q_ans: " << q_ans << "\n";
        if (q_ans == -1) {
            ans[qq] = 0;
        } else {
            ans[qq] = elts[q_ans].f + 1;
        }
    }
    // for (auto [u, v]: {mp(4LL,3LL), mp(4LL,5LL)}) {
    //     cout << "u: " << u << ", v: " << v << ", duv: " << get_dist(u,v) << "\n";
    // }
    vector<bool> exists(n+2);
    lep(i,1,n) {
        if (a[i] <= n+1) exists[a[i]] = true;
    }

    // cout << "exists:\n";
    // lep(i,0,n) {
    //     cout << exists[i] << " ";
    // }
    // cout << "\n";
    int mn = inf;
    lep(i,0,n+1) {
        if (!exists[i]) {
            mn = i;
            break;
        }
    }

    // cout << "mn: " << mn << "\n";

    lep(qq,1,q) {
        cout << min(mn, ans[qq]) << "\n";
    }




    
} 

/* stuff you should look for
	* int overflow, array bounds
	* special cases (n=1?)
	* do smth instead of nothing and stay organized
	* WRITE STUFF DOWN
	* DON'T GET STUCK ON ONE APPROACH
*/