#include <bits/stdc++.h>

#define long long long int
#define DEBUG
using namespace std;

// @author: pashka

vector<vector<pair<int, long>>> g;
vector<bool> z;

int size(int x, int p) {
    int res = 1;
    for (auto [y, _]: g[x]) {
        if (y != p && !z[y]) {
            res += size(y, x);
        }
    }
    return res;
}

int centroid;

int find_centroid(int x, int p, int n) {
    int res = 1;
    bool ok = true;
    for (auto [y, _]: g[x]) {
        if (y != p && !z[y]) {
            int s = find_centroid(y, x, n);
            if (s > n / 2) ok = false;
            res += s;
        }
    }
    if (res < n / 2) ok = false;
    if (ok) {
        centroid = x;
    }
    return res;
}

vector<vector<pair<int, long>>> up; // pairs (centroid, distance), from top

void add_dist(int x, int p, int c, long d) {
    up[x].push_back({c, d});
    for (auto [y, w]: g[x]) {
        if (y != p && !z[y]) {
            add_dist(y, x, c, d + w);
        }
    }
}

void build_centroid(int x, int p) {
    int n = size(x, p);
    find_centroid(x, p, n);

    x = centroid;

    add_dist(x, -1, x, 0);

    z[x] = true;

    for (auto [y, _]: g[x]) {
        if (!z[y]) {
            build_centroid(y, x);
        }
    }
}

//vector<vector<int>> s, ss, q, qq;
//vector<int> c;

//void update(int i, int d) { // updates sum for all centroids above
//    for (int j = 0; j < up[i].size(); j++) {
//        auto p = up[i][j];
//        s[p.first][c[i]] += p.second * d;
//        q[p.first][c[i]] += d;
//        if (j < up[i].size() - 1) {
//            auto pp = up[i][j + 1];
//            ss[pp.first][c[i]] += p.second * d;
//            qq[pp.first][c[i]] += d;
//        }
//    }
//}


int main() {
    ios::sync_with_stdio(false);

    int n, q;
    cin >> n >> q;
    vector<int> a(n);
    for (int i = 0; i < n; i++) cin >> a[i];
    g.resize(n);
    for (int i = 0; i < n - 1; i++) {
        int x, y, w;
        cin >> x >> y >> w;
        x--;
        y--;
        g[x].emplace_back(y, w);
        g[y].emplace_back(x, w);
    }
    z.resize(n);
    up.resize(n);
    build_centroid(0, -1);

    vector<vector<pair<long, pair<int, int>>>> c(n);
    vector<vector<long>> ll(n);
    vector<vector<pair<int, int>>> m1(n);
    vector<vector<pair<int, int>>> m2(n);

    for (int i = 0; i < n; i++) {
        int k = (int) up[i].size();
        for (int j = 0; j < k; j++) {
            auto p = up[i][j];
            c[p.first].push_back({p.second, {a[i], j == k - 1 ? i : up[i][j + 1].first}});
        }
    }

    for (int i = 0; i < n; i++) {
        sort(c[i].begin(), c[i].end());
        int k = c[i].size();
        ll[i].resize(k);
        for (int j = 0; j < k; j++) {
            ll[i][j] = c[i][j].first;
        }
        m1[i].resize(k + 1);
        m2[i].resize(k + 1);
        m1[i][k] = {INT_MAX, -1};
        m2[i][k] = {INT_MAX, -1};
        for (int j = k - 1; j >= 0; j--) {
            m1[i][j] = m1[i][j + 1];
            m2[i][j] = m2[i][j + 1];
            int w = c[i][j].second.first;
            int t = c[i][j].second.second;
            if (t == m1[i][j].second) {
                m1[i][j].first = min(m1[i][j].first, w);
            } else if (t == m2[i][j].second) {
                m2[i][j].first = min(m2[i][j].first, w);
            } else if (w < m1[i][j].first) {
                m2[i][j] = m1[i][j];
                m1[i][j] = {w, t};
            } else if (w < m2[i][j].first) {
                m2[i][j] = {w, t};
            }
            if (m1[i][j].first > m2[i][j].first) {
                swap(m1[i][j], m2[i][j]);
            }
        }
//        cout << i + 1 << ":\n";
//        for (auto p: c[i]) {
//            cout << p.first << " " << p.second.first << " " << p.second.second << "\n";
//        }
    }
    set<int> all;
    for (int i = 0; i < n; i++) all.insert(a[i]);
    int mx = 0;
    while (all.find(mx) != all.end()) mx++;
    while (q--) {
        int x;
        long d;
        cin >> x >> d;
        x--;
        d += 1;
        int k = (int) up[x].size();
        int res = mx;
        for (int j = 0; j < k; j++) {
            auto p = up[x][j];
            long dd = max(d - p.second, 0LL);
            int y = p.first;
            int e = lower_bound(ll[y].begin(), ll[y].end(), dd) - ll[y].begin();
            int cc = j == k - 1 ? x : up[x][j + 1].first;
            if (m1[y][e].second != cc) {
                res = min(res, m1[y][e].first);
            } else {
                res = min(res, m2[y][e].first);
            }
        }
        cout << res << "\n";
    }


    return 0;
}