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

//
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef __int128 i128;
#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);
}

// }}}

// {{{ convex

struct convex {
    int top;
    vector <pair <ll, ll> > stk;
    inline void init () { top = -1; }

    inline void push_back (pair <ll, ll> & e) {
        while (top > 0 && (i128) (stk[top - 1].se - e.se) * (stk[top].fi - stk[top - 1].fi) >=
                (i128) (stk[top - 1].se - stk[top].se) * (e.fi - stk[top - 1].fi)) -- top, stk.pop_back ();
        stk.emplace_back ( e ), ++ top;
    }
    inline ll query (ll d) {
        if (! ~ top) return INF;

        int l = 0, r = top - 1, mid, p = 0;
        while (l <= r) {
            mid = l + r >> 1;
            if ((i128) d * (stk[mid + 1].fi - stk[mid].fi) >= (stk[mid].se - stk[mid + 1].se)) p = mid, r = mid - 1;
            else l = mid + 1;
        }
        return stk[p].fi * d + stk[p].se;
    }
};

// }}}

// {{{ divide tree

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

convex con[N][LogN];

int rt, mx;
vector <pair <ll, ll> > pt;

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) {
    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);
}
void collect (int u, int pre, int & _cen, int & _aim) {
    pt.emplace_back ( w[u], dist (u, _cen) + dist (u, _aim));
    for (auto & v : to[u]) if (v.fi != pre && ! vis[v.fi]) collect (v.fi, u, _cen, _aim);
}
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

    rep (i, _dep, 0) {
        pt.clear (), collect (rt, 0, rt, cen[rt][i]);
        sort (pt.begin (), pt.end ()), con[rt][i].init ();
        for (auto & e : pt) con[rt][i].push_back ( e );
    }

    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, int _aim) {
    ll ret = dist (c, a) + con[c][_aim].query (d);
    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 = dist (a, c) + dist (b, c) + con[c][_dep].query (d);

    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;
}