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

char buf[1 << 20], *p1 = buf, *p2 = buf;
#define getchar() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 20, stdin), p1 == p2) ? EOF : *p1++)
template<class T>
il void read(T& x) {
    char ch;int f = 1;x = 0;
    do {ch = getchar();if(ch == '-')f = -1;} while(!isdigit(ch));
    do {x = x * 10 + (ch ^ 48);ch = getchar();} while(isdigit(ch));
    x *= f;
}

template<class T, class... Arg>
il void read(T& x, Arg&... nums) {
    read(x), read(nums...);
}

const int N = 2e5 + 5, LOG = 32 * 4.28;
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], pos3[N], pos4[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<ll, ll> f{inf, llinf};
} tr[N * LOG];

#define calc(f, x) (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<ll, 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);
    tr[pos3[u] = ++ct] = tr[pos1[u]];
    lazy(pos3[u], -(d[u] << 1));
    tr[pos4[u] = ++ct] = tr[pos2[u]];
    lazy(pos4[u], -(d[u] << 1));
}

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

namespace SegmentTree {
    struct node {
        int l, r;
        int pos;
    } tr[N << 2];
    void build(int k, int l, int r) {
        tr[k] = {l, r, 0};
        if(l == r) {
            tr[k].pos = pos1[rev[l]];
            return;
        }
        int mid = l + r >> 1;
        build(lc, l, mid);
        build(rc, mid + 1, r);
        if(top[rev[l]] == top[rev[r]])
            tr[k].pos = merge(tr[lc].pos, tr[rc].pos);
    }
    il ll ask(int k, int l, int r, int x) {
        if(l <= tr[k].l && tr[k].r <= r)
            return query(tr[k].pos, x);
        int mid = tr[k].l + tr[k].r >> 1;
        if(r <= mid)
            return ask(lc, l, r, x);
        if(l > mid)
            return ask(rc, l, r, x);
        return min(ask(lc, l, mid, x), ask(rc, mid + 1, r, x));
    }
}

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;
    read(n, m, q);
    rep(i, 1, n)
        read(a[i]);
    rep(i, 2, n) {
        int u, v;
        ll w;
        read(u, v, w);
        adde(u, v, w);
    }
    dep[1] = 1;
    dfs1(1, 1);
    dfs2(1, 1);
    dfs3(1);
    SegmentTree::build(1, 1, n);
    dfs4(1);
    rep(i, 1, q) {
        ll s, t;
        read(s, t);
        --s, --t;
        int k = abs(s / n - t / n);
        int u = s % n + 1, v = t % n + 1;
        ll dis = d[u] + d[v] - (d[LCA(u, v)] << 1);
        if(!k) {
            cout << dis << "\n";
            continue;
        }
        ll ans = llinf;
        while(top[u] != top[v]) {
            if(dep[top[u]] < dep[top[v]])
                swap(u, v);
            chkmn(ans, query(pos1[u], k));
            chkmn(ans, query(pos2[u], k));
            u = fa[top[u]];
        }
        if(dep[u] > dep[v])
            swap(u, v);
        chkmn(ans, query(pos2[v], k));
        chkmn(ans, SegmentTree::ask(1, id[u], id[v], k));
        v = u;
        while(u) {
            chkmn(ans, query(pos3[u], k) + (d[v] << 1));
            chkmn(ans, query(pos4[u], k) + (d[v] << 1));
            u = fa[top[u]];
        }
        ans += dis;
        cout << ans << "\n";
    }
    cerr << 1e3 * clock() / CLOCKS_PER_SEC << " ms\n";
    return 0;
}