#include <bits/stdc++.h>
#define INF 9e18
#define inf 1e9
#define ll long long
using namespace std;
const int N = 2e5 + 3;

inline int read() {
    char ch = getchar(); int x = 0;
    while (!isdigit(ch)) {ch = getchar();}
    while (isdigit(ch)) {x = x * 10 + ch - 48; ch = getchar();}
    return x;
}

inline ll Read() {
    char ch = getchar(); ll x = 0;
    while (!isdigit(ch)) {ch = getchar();}
    while (isdigit(ch)) {x = x * 10 + ch - 48; ch = getchar();}
    return x;
}

struct Node {
    int id, y, d;
    Node(int a = 0, int b = 0, int c = 0) {id = a; y = b; d = c;}
};
int n, m, T, a[N];
int depth[N], fa[N], sz[N], son[N], col[N];
int sum, root, mx[N];
ll dis[N], now[N], ans[N];
vector< pair<int, ll> > g[N];
bitset<N> vis;
vector<Node> vec[N], mem[N], nxt;
struct LC_Segment_Tree {
    struct node {
        int ls, rs, k; ll b;
        node() {ls = rs = k = 0; b = INF;}
    }t[N];
    // vector<node> t;
    int tot, fir;

    inline ll f(int x, int k, ll b) {return 1ll * k * x + b;}

    void update(int &rt, int l, int r, int k, ll b) {
        if (!rt) {
            rt = ++tot;
            // t.push_back(node());
            // cerr << rt << ' ' << t.size() << '\n';
            // if (tot >= t.size()) puts("qwq"), exit(0);
            t[tot].k = k; t[tot].b = b;
            return;
        }
        // if (rt >= t.size()) puts("qwq"), exit(0);
        // assert(rt < t.size());
        int mid = (l + r) >> 1;
        if (f(mid, k, b) < f(mid, t[rt].k, t[rt].b)) swap(k, t[rt].k), swap(b, t[rt].b);
        if (l == r) return;
        if (f(l, k, b) < f(l, t[rt].k, t[rt].b)) update(t[rt].ls, l, mid, k, b);
        if (f(r, k, b) < f(r, t[rt].k, t[rt].b)) update(t[rt].rs, mid + 1, r, k, b);
    }

    ll query(int rt, int l, int r, int x) {
        if (!rt) return INF;
        // assert(rt < t.size());
        if (l == r) return f(x, t[rt].k, t[rt].b);
        int mid = (l + r) >> 1; ll res = f(x, t[rt].k, t[rt].b);
        if (x <= mid) res = min(res, query(t[rt].ls, l, mid, x));
        else res = min(res, query(t[rt].rs, mid + 1, r, x));
        return res;
    }

    void init() {
        for (int i = 0; i <= tot; ++i) t[i] = node();
        tot = fir = 0;
    }

    // void init() {t.clear(); t.push_back(node()); tot = fir = 0;}
}t[3];

void dfs1(int x, int pa, int d, int anc) {
    t[0].update(t[0].fir, 0, inf, a[x], dis[x] + dis[x]);
    depth[x] = d; fa[x] = pa; sz[x] = 1; col[x] = anc;
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (y == pa || vis[y]) continue;
        dis[y] = dis[x] + tmp.second;
        dfs1(y, x, d + 1, anc == -1 ? y : anc);
        sz[x] += sz[y];
        if (sz[y] > sz[son[x]]) son[x] = y;
    }
}

void dfs2(int x) {
    for (auto tmp : vec[x]) {
        int y = tmp.y;
        if (col[x] == col[y]) {
            int id = tmp.id, d = tmp.d;
            ans[id] = min(ans[id], t[0].query(t[0].fir, 0, inf, d) + dis[x] + dis[y]);
            nxt.push_back(tmp);
        }
        else mem[x].push_back(tmp);
    }
    swap(vec[x], nxt);
    nxt.clear();
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (y == fa[x] || vis[y]) continue;
        dfs2(y);
    }
}

void update(int x, ll val) {
    t[1].update(t[1].fir, 0, inf, a[x], dis[x] + dis[x] - val - val);
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (y == fa[x] || vis[y]) continue;
        update(y, val);
    }
}

void query(int x) {
    for (auto tmp : mem[x]) {
        int y = tmp.y, id = tmp.id, d = tmp.d;
        ans[id] = min(ans[id], t[1].query(t[1].fir, 0, inf, d) + dis[x] + dis[y]);
    }
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (y == fa[x] || vis[y]) continue;
        query(y);
    }
}

void Update(int x) {
    t[2].update(t[2].fir, 0, inf, a[x], dis[x] + dis[x]);
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (y == fa[x] || vis[y]) continue;
        Update(y);
    }
}

void Query(int x, int anc) {
    for (auto tmp : mem[x]) {
        int y = tmp.y, d = tmp.d, id = tmp.id;
        ans[id] = min(ans[id], t[2].query(t[2].fir, 0, inf, d) + dis[x] + dis[y] - dis[anc] - dis[anc]);
        // printf("[%d %d %lld]\n", anc, id, ans[id]);
    }
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (y == fa[x] || vis[y]) continue;
        Query(y, anc);
    }
}

void dfs3(int x) {
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (y == fa[x] || y == son[x] || vis[y]) continue;
        dfs3(y); t[2].init();
    }
    if (son[x]) dfs3(son[x]);
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (y == fa[x] || y == son[x] || vis[y]) continue;
        Update(y);
    }
    t[2].update(t[2].fir, 0, inf, a[x], dis[x] + dis[x]);
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (y == fa[x] || y == son[x] || vis[y]) continue;
        // printf("[%d %d]\n", y, x);
        Query(y, x);
    }
    for (auto tmp : mem[x]) {
        int y = tmp.y, id = tmp.id, d = tmp.d;
        ans[id] = min(ans[id], t[2].query(t[2].fir, 0, inf, d) + dis[y] - dis[x]);
        // printf("[%d %d %d]\n", x, id, ans[id]);
    }
}

void dfs4(int x) {
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (y == fa[x] || y == son[x] || vis[y]) continue;
        update(y, dis[x]);
    }
    t[1].update(t[1].fir, 0, inf, a[x], 0);
    for (auto tmp : mem[x]) {
        int y = tmp.y, id = tmp.id, d = tmp.d;
        ans[id] = min(ans[id], t[1].query(t[1].fir, 0, inf, d) + dis[x] + dis[y]);
    }
    mem[x].clear();
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (y == fa[x] || y == son[x] || vis[y]) continue;
        query(y);
    }
    if (son[x]) dfs4(son[x]);
    else t[1].init();
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (y == fa[x] || y == son[x] || vis[y]) continue;
        dfs4(y);
    }
}

void get_rt(int x, int pa) {
    sz[x] = 1; mx[x] = 0;
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (y == pa || vis[y]) continue;
        get_rt(y, x);
        sz[x] += sz[y];
        mx[x] = max(mx[x], sz[y]);
    }
    mx[x] = max(mx[x], n - sz[x]);
    if (mx[x] < mx[root]) root = x;
}

void work(int x) {
    t[0].init(); t[1].init();
    dis[x] = 0; vis[x] = 1;
    dfs1(x, x, 1, -1); dfs2(x); dfs3(x);
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (vis[y]) continue;
        sum = sz[y]; mx[root = 0] = inf; get_rt(y, 0); work(root);
    }
}

void solve(int rt) {
    t[0].init(); t[1].init(); dis[rt] = 0;
    dfs1(rt, rt, 1, -1);
    for (int i = 1; i <= n; ++i)
        for (auto tmp : vec[i])
            if (tmp.y == rt) mem[i].push_back(tmp);
    dfs3(rt); t[2].init(); dfs4(rt);
    // printf("[%d %lld]\n", rt, ans[1]);
    for (int i = 1; i <= n; ++i) son[i] = 0;
}

int main() {
    n = read(); m = read(); T = read();
    for (int i = 1; i <= n; ++i) a[i] = read();
    for (int i = 1; i < n; ++i) {
        int x = read(), y = read(); ll v = Read();
        g[x].push_back(make_pair(y, v));
        g[y].push_back(make_pair(x, v));
    }
    for (int i = 1; i <= T; ++i) {
        ll xx = Read() - 1, yy = Read() - 1;
        int x = xx % n + 1, y = yy % n + 1, d = xx / n - yy / n;
        if (d < 0) d = -d;
        // printf("[%d %d %d]\n", x, y, d);
        vec[x].push_back(Node(i, y, d));
        vec[y].push_back(Node(i, x, d));
        ans[i] = INF;
    }
    // solve(3); return 0;
    for (int i = 1; i <= n; ++i) solve(i);
    // solve(63);
    for (int i = 1; i <= T; ++i) printf("%lld\n", ans[i]);
    return 0;
}

//考虑点分治套点分治，递归变成子任务6