#include<bits/stdc++.h>
#define rep(i, a, b) for(int i = (a);i <= (b);++i)
#define per(i, a, b) for(int i = (a);i >= (b);--i)
#define lc (k << 1)
#define rc (k << 1 | 1)
#define lowbit(x) ((x) & -(x))
#define odd(x) ((x) & 1)
#define even(x) (!odd(x))
#define fir first
#define sec second
#define pb push_back
#define il inline
#define all(x) begin(x), end(x)
#define rall(x) rbegin(x), rend(x)
#define i128 __int128
#define f128 __float128
#define pii pair<int, int>
#define pli pair<ll, int>
#define pll pair<ll, ll>
#define SZ(x) ((int)(x).size())
#define debug(x) cerr << "In Line " << __LINE__ << " the " << #x << " = " << (x) << "\n"
using namespace std;
using ll = long long;
using ull = unsigned long long;
template<class T> using vc = vector<T>;
template<class Tx, class Ty>
il void chkmx(Tx& x, const Ty y) {x = max<common_type_t<Tx, Ty>>(x, y);}
template<class Tx, class Ty>
il void chkmn(Tx& x, const Ty y) {x = min<common_type_t<Tx, Ty>>(x, y);}
const int inf = 0x3f3f3f3f;
const ll llinf = 0x3f3f3f3f3f3f3f3fll;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
bool ms;

const int N = 2e5 + 5, LOG = 32 * 5;
int head[N], cnt;
int fa[N], dep[N], sz[N], son[N];
int top[N], id[N], rev[N], tot;
int pos1[N], pos2[N], ct;
int a[N], m;
ll d[N];

struct node {
    int to;
    ll w;
    int nxt;
} e[N << 1];

void init() {
    cnt = 0;
    memset(head, -1, sizeof(head));
}

void add(int u, int v, ll w) {
    e[cnt] = {v, w, head[u]};
    head[u] = cnt++;
}

void adde(int u, int v, ll w) {
    add(u, v, w);
    add(v, u, w);
}

void dfs1(int u, int f) {
    sz[u] = 1;
    for(int i = head[u];~i;i = e[i].nxt) {
        int v = e[i].to;
        ll w = e[i].w;
        if(v == f)
            continue;
        fa[v] = u;
        dep[v] = dep[u] + 1;
        d[v] = d[u] + w;
        dfs1(v, u);
        sz[u] += sz[v];
        if(sz[v] > sz[son[u]])
            son[u] = v;
    }
}

void dfs2(int u, int t) {
    top[u] = t;
    id[u] = ++tot;
    rev[tot] = u;
    if(!son[u])
        return;
    dfs2(son[u], t);
    for(int i = head[u];~i;i = e[i].nxt) {
        int v = e[i].to;
        if(v != fa[u] && v != son[u])
            dfs2(v, v);
    }
}

il int LCA(int u, int v) {
    while(top[u] != top[v]) {
        if(dep[top[u]] < dep[top[v]])
            swap(u, v);
        u = fa[top[u]];
    }
    return dep[u] < dep[v] ? u : v;
}

struct LiChaoTree {
    int ls, rs;
    ll lz;
    pair<int, ll> f{inf, llinf};
} tr[N * LOG];

il ll calc(pair<int, ll>& f, ll x) {
    return f.fir * x + f.sec;
}

il void lazy(int k, ll v) {
    tr[k].lz += v;
    tr[k].f.sec += v;
}

il void push_down(int k) {
    if(tr[k].lz) {
        if(tr[k].ls) {
            tr[++ct] = tr[tr[k].ls];
            lazy(tr[k].ls = ct, tr[k].lz);
        }
        if(tr[k].rs) {
            tr[++ct] = tr[tr[k].rs];
            lazy(tr[k].rs = ct, tr[k].lz);
        }
        tr[k].lz = 0;
    }
}

il void update(int& k, pair<int, ll> x, int L = 1, int R = m) {
    tr[++ct] = tr[k];
    push_down(k = ct);
    int mid = L + R >> 1;
    if(calc(x, mid) < calc(tr[k].f, mid))
        swap(x, tr[k].f);
    if(calc(x, L) < calc(tr[k].f, L))
        update(tr[k].ls, x, L, mid);
    else if(calc(x, R) < calc(tr[k].f, R))
        update(tr[k].rs, x, mid + 1, R);
}

il int merge(int x, int y, int L = 1, int R = m) {
    if(!x || !y)
        return x + y;
    int mid = L + R >> 1;
    if(calc(tr[x].f, mid) > calc(tr[y].f, mid))
        swap(x, y);
    if(L == R)
        return x;
    push_down(x);
    push_down(y);
    int k = ++ct;
    tr[k].f = tr[x].f;
    tr[k].ls = merge(tr[x].ls, tr[y].ls, L, mid);
    tr[k].rs = merge(tr[x].rs, tr[y].rs, mid + 1, R);
    update(k, tr[y].f, L, R);
    return k;
}

il ll query(int k, int p, int L = 1, int R = m) {
    if(!k || L == R)
        return calc(tr[k].f, p);
    push_down(k);
    int mid = L + R >> 1;
    ll ans = p <= mid ? query(tr[k].ls, p, L, mid) : query(tr[k].rs, p, mid + 1, R);
    return min(ans, calc(tr[k].f, p));
}

void dfs3(int u) {
    update(pos1[u], {a[u], 0});
    if(!son[u]) {
        pos2[u] = pos1[u];
        return;
    }
    dfs3(son[u]);
    ll W = 0;
    for(int i = head[u];~i;i = e[i].nxt) {
        int v = e[i].to;
        ll w = e[i].w;
        if(v != fa[u] && v != son[u]) {
            dfs3(v);
            tr[++ct] = tr[pos2[v]];
            lazy(ct, w << 1);
            pos1[u] = merge(pos1[u], ct);
        } else if(v == son[u])
            W = w;
    }
    tr[++ct] = tr[pos2[son[u]]];
    lazy(ct, W << 1);
    pos2[u] = merge(pos1[u], ct);
}

void dfs4(int u) {
    if(son[u])
        pos1[son[u]] = merge(pos1[u], pos1[son[u]]);
    for(int i = head[u];~i;i = e[i].nxt) {
        int v = e[i].to;
        if(v != fa[u])
            dfs4(v);
    }
}

bool mt;
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);
    cerr << fabs(&ms - &mt) / 1024 / 1024 << "\n";
    init();
    int n, q;
    cin >> n >> m >> q;
    rep(i, 1, n)
        cin >> a[i];
    rep(i, 2, n) {
        int u, v;
        ll w;
        cin >> u >> v >> w;
        adde(u, v, w);
    }
    dep[1] = 1;
    dfs1(1, 1);
    dfs2(1, 1);
    dfs3(1);
    dfs4(1);
    while(q--) {
        ll s, t;
        cin >> s >> t;
        assert(s == 1);
        --s, --t;
        int i = s / n, j = t / n, k = abs(i - j);
        int u = s % n + 1, v = t % n + 1;
        int l = LCA(u, v);
        ll dis = d[u] + d[v] - (d[l] << 1);
        if(!k) {
            cout << dis << "\n";
            continue;
        }
        ll ans = llinf;
        while(v) {
            chkmn(ans, query(pos2[v], k));
            chkmn(ans, query(pos1[v], k));
            v = fa[top[v]];
        }
        ans += dis;
        cout << ans << "\n";
    }
    cerr << 1e3 * clock() / CLOCKS_PER_SEC << " ms\n";
    return 0;
}