// my name is huangzirui, i (jp01) will ak ioi 2024

//
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define debug(...) fprintf (stderr, __VA_ARGS__)

#define fi first
#define se second
#define lep(i, l, r) for (int i = (l), i##_ext = (r); i <= i##_ext; ++ i)
#define rep(i, r, l) for (int i = (r), i##_ext = (l); i >= i##_ext; -- i)

char _c; bool _f; template <class T> inline void IN (T & x) {
	_f = 0, x = 0; while (_c = getchar (), ! isdigit (_c)) if (_c == '-') _f = 1;
	while (isdigit (_c)) x = x * 10 + _c - '0', _c = getchar (); if (_f) x = -x;
}

template <class T> inline void chkmin (T & x, T y) { if (x > y) x = y; }
template <class T> inline void chkmax (T & x, T y) { if (x < y) x = y; }

const int N = 2e5 + 5;
const int LogN = 20;

const ll INF = 4e18;

int n, m, q;

ll w[N];
vector <pair <int, ll> > to[N];

// {{{ tree

int st[LogN][N], Log2[N];

int tim, par[N], dfn[N], lay[N];
ll len[N];

inline int chktop (int a, int b) {
    return lay[a] < lay[b] ? a : b;
}

void dfs (int u, int pre) {
    par[u] = pre, st[0][dfn[u] = ++ tim] = pre, lay[u] = lay[pre] + 1;
    for (auto & v : to[u]) if (v.fi != pre) {
        len[v.fi] = len[u] + v.se, dfs (v.fi, u);
    }
}
inline void build_st () {
    Log2[0] = -1; lep (i, 1, n) Log2[i] = Log2[i >> 1] + 1;

    dfs (1, 0);
    lep (j, 1, 19) lep (i, 1, n - (1 << j) + 1) {
        st[j][i] = chktop (st[j - 1][i], st[j - 1][i + (1 << j - 1)]);
    }
}

inline int lca (int x, int y) {
    if (x == y) return x;
    if (x = dfn[x], y = dfn[y], x > y) swap (x, y); ++ x;
    int ret = Log2[y - x + 1];
    return chktop (st[ret][x], st[ret][y - (1 << ret) + 1]);
}
inline ll dist (int x, int y) {
    return len[x] + len[y] - (len[lca (x, y)] << 1ll);
}

// }}}

// {{{ divide tree

int cen[N][LogN], adj[N][LogN], lst_rt[N], dep[N], siz[N];
bool vis[N];

int rt, mx;
vector <int> pt[N];

void gsiz (int u, int pre) {
    siz[u] = 1;
    for (auto & v : to[u]) if (v.fi != pre && ! vis[v.fi]) {
        gsiz (v.fi, u), siz[u] += siz[v.fi];
    }
}
void find_rt (int u, int pre, int & all) {
    int tp = all - siz[u];
    for (auto & v : to[u]) if (v.fi != pre && ! vis[v.fi]) {
        find_rt (v.fi, u, all), chkmax (tp, siz[v.fi]);
    }
    if (tp < mx) mx = tp, rt = u;
}

void color (int u, int pre, int & _cen, int & _adj) {
    pt[_cen].emplace_back (u);
    cen[u][dep[_cen]] = _cen;
    adj[u][dep[_cen]] = _adj;
    for (auto & v : to[u]) if (v.fi != pre && ! vis[v.fi]) color (v.fi, u, _cen, _adj);
}
int build_tr (int u, int all, int _dep = 0) {
    rt = 0, mx = all + 1, gsiz (u, 0), find_rt (u, 0, all); // find rt
    dep[rt] = _dep, vis[rt] = true, color (rt, 0, rt, u); // cen & adj

    /* */

    int _rt = rt; gsiz (_rt, 0);
    for (auto & v : to[_rt]) if (! vis[v.fi]) build_tr (v.fi, siz[v.fi], _dep + 1);
    return _rt;
}

/* ll query_1p (int c, int a, int & d, int _dep) {
    ll ret = INF;
    for (int & k : pt[c]) chkmin (ret, dist (k, c) + w[k] * d + dist (k, cen[c][_dep - 1]));
    ret += dist (c, a);

    if (a != c) chkmin (ret, dist (c, cen[c][_dep - 1]) + query_1p (cen[a][_dep + 1], a, d, _dep + 1));
    return ret;
} */
ll query_1p (int c, int a, int & d, int _dep, int aim) {
    ll ret = INF;
    for (int & k : pt[c]) chkmin (ret, dist (a, k) + w[k] * d + dist (k, cen[c][aim]));
    ret += dist (c, a);

    if (a != c) chkmin (ret, query_1p (cen[a][_dep + 1], a, d, _dep + 1, aim));
    return ret;
}
ll query_2p (int c, int a, int b, int & d, int _dep) {
    ll ret = INF;
    for (int & k : pt[c]) chkmin (ret, dist (c, k) * 2 + w[k] * d);
    ret += dist (a, c) + dist (b, c);

    if (adj[a][_dep + 1] == adj[b][_dep + 1]) {
        if (a == c && b == c) return ret;
        return min (ret, query_2p (cen[a][_dep + 1], a, b, d, _dep + 1));
    }

    if (a != c) chkmin (ret, dist (b, c) + query_1p (cen[a][_dep + 1], a, d, _dep + 1, _dep));
    if (b != c) chkmin (ret, dist (a, c) + query_1p (cen[b][_dep + 1], b, d, _dep + 1, _dep));
    return ret;
}

// }}}

inline void input () {
    IN (n), IN (m), IN (q);
    lep (i, 1, n) IN (w[i]);

    int a, b; ll v;
    lep (i, 1, n - 1) {
        IN (a), IN (b),IN (v);
        to[a].emplace_back ( b, v );
        to[b].emplace_back ( a, v );
    }
}
signed main () {
    input (), build_st ();
    rt = build_tr (1, n);

    ll t1, t2; int u, v, d;
    while (q -- ) {
        IN (t1), IN (t2), u = (t1 - 1) % n + 1, v = (t2 - 1) % n + 1, d = abs ((t1 - 1) / n - (t2 - 1) / n);
        printf ("%lld\n", query_2p (rt, u, v, d, 0));
    }
    return 0;
}