// https://szkopul.edu.pl/problemset/problem/CACYTyPO4YJxyZzNumr0zr5e/site/?key=statement

// Kolacje

#include <bits/stdc++.h>

using namespace std;

#define int long long

constexpr int sizik = 100 * 1001, sizik2 = 18;

#define ar std::array
#define pr std::pair
#define vec std::vector

// #define GARY_DBG

typedef std::map<int, vec<ar<int, 2>>> _kra;
typedef std::pair<int, int> Qtype;

int timer, pre[sizik], post[sizik];

struct PreComparator {
    bool operator()(int a, int b) const { return pre[a] < pre[b]; }
};

typedef std::vector<std::set<int, PreComparator>> VS_type;

int n, r;

int visited[sizik], visited_cnt = 1;

std::bitset<sizik> wasThisBadboy;
int kolor[sizik];
_kra kra_main;

int d[sizik];

struct _cmp {
    bool operator()(const Qtype& a, const Qtype& b) const { return a > b; }
};

void Dijkstra(_kra& kra, int type, VS_type& VS) {
    visited_cnt++;

    std::priority_queue<Qtype, vec<Qtype>, _cmp> q;
    for (const auto& a : VS[type]) {
        if (kolor[a] == type) {
            q.push({0, a});
            d[a] = 0;
        }
    }

    while (!q.empty()) {
        const auto [dist, u] = q.top();
        q.pop();

        if (visited[u] == visited_cnt) continue;

        d[u] = dist;
        visited[u] = visited_cnt;

        for (const auto& [v, w] : kra[u]) {
            q.push({w + dist, v});
        }
    }
}

int jump[sizik][sizik2];
int jump1[sizik][sizik2];
int mini_d[sizik][sizik2];

int depth[sizik];
int depth1[sizik];

int dist_from_root[sizik];

void DFS_first(int v, int p, int op_dist, _kra& kra) {
    pre[v] = ++timer;

    depth[v] = depth[p] + 1;

    dist_from_root[v] = op_dist;

    jump[v][0] = p;
    for (int i = 1; i < sizik2; i++) {
        jump[v][i] = jump[jump[v][i - 1]][i - 1];
    }

    for (const auto& [u, w] : kra[v]) {
        if (u == p) continue;
        DFS_first(u, v, op_dist + w, kra);
    }

    post[v] = ++timer;
}

void DFSvi(int v, int p, _kra& kra) {
    depth1[v] = depth1[p] + 1;

    jump1[v][0] = p;
    for (int i = 1; i < sizik2; i++) {
        jump1[v][i] = jump1[jump1[v][i - 1]][i - 1];
    }

    mini_d[v][0] = d[v];
    for (int i = 1; i < sizik2; i++) {
        mini_d[v][i] = std::min(mini_d[v][i - 1], mini_d[jump1[v][i - 1]][i - 1]);
    }

    for (const auto& [u, w] : kra[v]) {
        if (u == p) continue;
        DFSvi(u, v, kra);
    }
}

bool is_ancestor(int u, int v) {
    return pre[u] <= pre[v] && post[u] >= post[v];
}

int lca(int u, int v) {
    if (is_ancestor(u, v)) return u;
    if (is_ancestor(v, u)) return v;
    for (int i = sizik2 - 1; i >= 0; --i) {
        if (!is_ancestor(jump[u][i], v)) u = jump[u][i];
    }
    return jump[u][0];
}

int get_mini(int u, int v) {
    int res = INT64_MAX;

    auto lift = [&](int& x, int steps) {
        for (int i = sizik2 - 1; i >= 0; --i) {
            if ((1 << i) <= steps) {
                if (mini_d[x][i] == 0) {
                    res = 0;
                    return;
                }
                res = std::min(res, mini_d[x][i]);
                x = jump1[x][i];
                steps -= (1 << i);
            }
        }
    };

    int l = lca(u, v);

    if (d[u] == 0 || d[v] == 0 || d[l] == 0) return 0;

    lift(u, depth1[u] - depth1[l]);
    if (res == 0) return 0;
    lift(v, depth1[v] - depth1[l]);
    if (res == 0) return 0;

    res = std::min(res, d[l]);
    return res;
}

int distance_o(int u, int v) {
    int l = lca(u, v);
    return dist_from_root[u] + dist_from_root[v] - 2 * dist_from_root[l];
}

std::vector<ar<int, 3>> zapytania_do_rozwazenia[sizik];
int final_ans[sizik];

void solve_spb(int local_color, VS_type& VS) {
    if (!wasThisBadboy[local_color]) {
        for (const auto& [i, a, b] : zapytania_do_rozwazenia[local_color]) {
            final_ans[i] = INT64_MAX;
        }
        return;
    }

    std::vector<int> was;
    for (const auto& a : VS[local_color]) {
        was.push_back(a);
    }
    int nk = (int)was.size();

    std::sort(was.begin(), was.end(), PreComparator());

    for (int i = 0; i < nk - 1; i++) {
        VS[local_color].insert(lca(was[i], was[i + 1]));
    }
    _kra local_kra;

    was.clear();
    for (const auto& a : VS[local_color]) {
        was.push_back(a);

        depth1[a] = 0;
        d[a] = INT64_MAX;
        for (int j = 0; j < sizik2; j++) {
            jump1[a][j] = 0;
            mini_d[a][j] = 0;
        }
    }

    std::sort(was.begin(), was.end(), PreComparator());

    nk = (int)was.size();
    for (int i = 0; i < nk - 1; i++) {
        // (u,v) ~> (lca(u,v),v)
        int u = lca(was[i], was[i + 1]);
        int v = was[i + 1];

        int local_dist = distance_o(u, v);
        local_kra[u].push_back({v, local_dist});
        local_kra[v].push_back({u, local_dist});
    }

    Dijkstra(local_kra, local_color, VS);
    DFSvi(was[0], was[0], local_kra);

    for (const auto& [i, a, b] : zapytania_do_rozwazenia[local_color]) {
        int ans_for_this = 2 * get_mini(a, b) + distance_o(a, b);
        final_ans[i] = ans_for_this;
    }
}

void solve() {
    std::cin >> n >> r;

    VS_type VS(r + 2);

    for (int i = 1; i <= n; i++) {
        std::cin >> kolor[i];
        wasThisBadboy[kolor[i]] = 1;
    }

    for (int i = 0; i < n - 1; i++) {
        // [v, u, cost]
        int a, b, c;
        std::cin >> a >> b >> c;

        kra_main[a].push_back({b, c});
        kra_main[b].push_back({a, c});
    }

    for (int i = 1; i <= n; i++) {
        std::sort(kra_main[i].begin(), kra_main[i].end());
    }

    DFS_first(1, 1, 0, kra_main);

    for (int i = 1; i <= n; i++) {
        VS[kolor[i]].insert(i);
    }

    int q;
    std::cin >> q;

    for (int i = 1; i <= q; i++) {
        int a, b, c;
        std::cin >> a >> b >> c;
        zapytania_do_rozwazenia[c].push_back({i, a, b});
        VS[c].insert(a);
        VS[c].insert(b);
    }

    for (int i = 1; i <= r; i++) {
        solve_spb(i, VS);
    }

    for (int i = 1; i <= q; i++) {
        if (final_ans[i] == INT64_MAX) {
            std::cout << "-1\n";
        } else {
            std::cout << final_ans[i] << '\n';
        }
    }
}

int32_t main() {
#ifndef GARY_DBG
    std::ios_base::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);
#endif

    int t = 1;
    // std::cin >> t;

    for (; t > 0; t--) {
        solve();
    }

    return 0;
}