/* cth2021_12c_climb.cpp */
#include <bits/stdc++.h>

using i64 = long long;
constexpr int N = 2e5 + 5, Q = 2e5 + 5, S = 2e7;
constexpr i64 inf = 2e18;

struct Segment {
    int k; i64 b;
    i64 operator()(int x) const { return 1ll * k * x + b; }
};
struct Node {
    Node *l, *r;
    Segment v;
} *null;
Node *newNode() {
    static Node t[S], *p = t;
    return *p = *null, p++;
}
void modify(Node *&u, int l, int r, Segment x) {
    if (u == null) return u = newNode(), u->v = x, void();
    int m = (l + r) / 2;
    if (x(m) < u->v(m)) std::swap(x, u->v);
    if (r - l == 1) return;
    if (x(l) < u->v(l)) modify(u->l, l, m, x);
    else if (x(r - 1) < u->v(r - 1)) modify(u->r, m, r, x);
}
i64 query(Node *u, int l, int r, int p) {
    if (u == null) return inf;
    int m = (l + r) / 2; i64 res = u->v(p);
    if (p < m) res = std::min(res, query(u->l, l, m, p));
    else res = std::min(res, query(u->r, m, r, p));
    return res;
}

int n, m, q, a[N]; i64 ans[Q];
std::vector<std::pair<int, i64>> adj[N];

int fa[N], sz[N], in[N], top[N], cur; i64 dep[N];
void dfs1(int u) {
    auto it = std::find_if(adj[u].begin(), adj[u].end(), [&](auto x) { return x.first == fa[u]; });
    if (it != adj[u].end()) adj[u].erase(it);
    sz[u] = 1;
    for (auto &x : adj[u]) {
        auto [v, w] = x; fa[v] = u, dep[v] = dep[u] + w, dfs1(v);
        if (sz[v] > sz[adj[u].front().first]) std::swap(adj[u].front(), x);
    }
}
void dfs2(int u) {
    in[u] = cur++;
    for (auto [v, w] : adj[u]) top[v] = v == adj[u].front().first ? top[u] : v, dfs2(v);
}
int lca(int u, int v) {
    while (top[u] != top[v]) {
        if (in[u] < in[v]) v = fa[top[v]];
        else u = fa[top[u]];
    }
    return in[u] < in[v] ? u : v;
}

// std::vector<std::array<int, 3>> qry[N];
std::vector<int> qry[N];
int qk[Q]; i64 qd[Q];
int cnt;
void collect(int u, Node *&rt, i64 x) {
    ++cnt; // assert(cnt <= 5000000);
    modify(rt, 0, m, Segment{a[u], 2 * dep[u] + x});
    for (auto [v, w] : adj[u]) collect(v, rt, x);
}
Node *rt[N];
void dfs3(int u) {
    rt[u] = u == top[u] ? null : rt[fa[u]];
    modify(rt[u], 0, m, Segment{a[u], 0});
    for (auto [v, w] : adj[u]) {
        if (v == adj[u].front().first) {
            for (auto [x, y] : adj[u]) if (x != v) collect(x, rt[u], -2 * dep[u]);
            for (auto id : qry[u]) {
                ans[id] = std::min(ans[id], query(rt[u], 0, m, qk[id]));
            }
        }
        dfs3(v);
    }
}

int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);

    null = new Node{}, null->l = null->r = null, null->v = Segment{0, inf};

    std::cin >> n >> m >> q;
    for (int i = 0; i < n; ++i) std::cin >> a[i];
    for (int i = 0; i < n - 1; ++i) {
        int u, v; i64 w; std::cin >> u >> v >> w, --u, --v;
        adj[u].push_back({v, w}), adj[v].push_back({u, w});
    }
    
    fa[0] = -1, dfs1(0), dfs2(0);

    for (int i = 0; i < q; ++i) {
        i64 x, y; std::cin >> x >> y, --x, --y;
        int u = x % n, v = y % n; qk[i] = std::abs(x / n - y / n);
        qd[i] = dep[u] + dep[v];
        while (top[u] != top[v]) {
            if (in[u] > in[v]) std::swap(u, v);
            assert(u == 0);
            // qry[top[v]].push_back({top[v], in[v] + 1, i}), v = fa[top[v]];
            qry[v].push_back(i), v = fa[top[v]];
        }
        if (in[u] > in[v]) std::swap(u, v);
        // qry[top[u]].push_back({in[u], in[v] + 1, i});
        assert(u == 0);
        qd[i] -= 2 * dep[u];
        qry[v].push_back(i);
    }
    std::fill(ans, ans + q, inf);

    dfs3(0);

    for (int i = 0; i < q; ++i) std::cout << ans[i] + qd[i] << '\n';

    std::cerr << cnt << '\n';

    return 0;
}