#include <bits/stdc++.h>

namespace IO {
    #ifdef _DEBUG
    constexpr int MAX_SIZE = 1;
    #else
    constexpr int MAX_SIZE = 1 << 20;
    #endif
    class Reader {
    private:
        FILE *file;
        char buff[MAX_SIZE], *p1, *p2;
        int getchar() {
            if (p1 == p2) p2 = (p1 = buff) + fread(buff, 1, MAX_SIZE, file);
            return p1 == p2 ? EOF : *p1++;
        }
    public:
        Reader(FILE *_file) {
            file = _file;
            p1 = p2 = buff;
        }
        Reader(const char* file_dir) {
            file = std::fopen(file_dir, "r");
            p1 = p2 = buff;
        }
        void read() {}
        template<typename... Args>
        void read(int &x, Args &...other) {
            int f, ch;
            x = f = 0;
            ch = getchar();
            for (; !isdigit(ch); ch = getchar()) f ^= ch == '-';
            for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ 48);
            if (f) x = -x;
            read(other...);
        }
        template<typename... Args>
        void read(long long &x, Args &...other) {
            int f, ch;
            x = f = 0;
            ch = getchar();
            for (; !isdigit(ch); ch = getchar()) f ^= ch == '-';
            for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ 48);
            if (f) x = -x;
            read(other...);
        }
        template<typename... Args>
        void read(__int128 &x, Args &...other) {
            int f, ch;
            x = f = 0;
            ch = getchar();
            for (; !isdigit(ch); ch = getchar()) f ^= ch == '-';
            for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ 48);
            if (f) x = -x;
            read(other...);
        }
       template<typename... Args>
        void read(unsigned int &x, Args &...other) {
            int ch;
            x = 0;
            ch = getchar();
            for (; !isdigit(ch); ch = getchar()) ;
            for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ 48);
            read(other...);
        }
        template<typename... Args>
        void read(unsigned long long &x, Args &...other) {
            int ch;
            x = 0;
            ch = getchar();
            for (; !isdigit(ch); ch = getchar()) ;
            for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ 48);
            read(other...);
        }
        template<typename... Args>
        void read(unsigned __int128 &x, Args &...other) {
            int ch;
            x = 0;
            ch = getchar();
            for (; !isdigit(ch); ch = getchar()) ;
            for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ 48);
            read(other...);
        }
        template<typename... Args>
        void read(double &x, Args &...other) {
            int f, ch;
            x = f = 0;
            ch = getchar();
            for (; !isdigit(ch); ch = getchar()) f ^= ch == '-';
            for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ 48);
            if (ch == '.') {
                double e = 1;
                for (ch = getchar(); isdigit(ch); ch = getchar())
                    x += (ch ^ 48) * (e *= .1);
            }
            if (f) x = -x;
            read(other...);
        }
        template<typename... Args>
        void read(char &ch, Args &...other) {
            ch = getchar();
            while (!isgraph(ch)) ch = getchar();
            read(other...);
        }
        template<typename... Args>
        void read(std::string &s, Args &...other) {
            char ch;
            s = "";
            ch = getchar();
            for (; !isgraph(ch);) ch = getchar();
            for (; isgraph(ch); ch = getchar()) s += ch;
            read(other...);
        }
        template<typename... Args>
        void read(long double &x, Args &...other) {
            int f, ch;
            x = f = 0;
            ch = getchar();
            for (; !isdigit(ch); ch = getchar()) f ^= ch == '-';
            for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ 48);
            if (ch == '.') {
                long double e = 1;
                for (ch = getchar(); isdigit(ch); ch = getchar())
                    x += (ch ^ 48) * (e *= .1);
            }
            if (f) x = -x;
            read(other...);
        }
        void read(char* s) {
            char ch;
            ch = getchar();
            while (!isgraph(ch)) ch = getchar();
            for (; isgraph(ch); ch = getchar()) *s++ = ch;
            *s = 0;
        }
    };
}
IO::Reader reader(stdin);

using LL = long long;
constexpr int inf32 = (int)(1e9) + 9;
constexpr LL inf64 = (LL)(1e18) + 18;

constexpr int N = 200005;

int n, m, q, a[N];
std::vector<std::pair<int, LL>> graph[N];

struct Func {
    LL k, b;
    LL operator()(LL x) { return k * x + b; }
};
struct ST1 {
    struct Node {
        int son[2];
        Func func;
    };
    int tot;
    Node node[N * 400];
    int &ls(int u) { return node[u].son[0]; }
    int &rs(int u) { return node[u].son[1]; }
    void insert(int &u, int l, int r, Func func) {
        if (!u) {
            u = ++tot;
            ls(u) = rs(u) = 0;
            node[u].func = func;
            return;
        }
        int mid = (l + r) >> 1;
        if (func(mid) < node[u].func(mid)) std::swap(func, node[u].func);
        if (l == r) return;
        if (func(l) < node[u].func(l)) insert(ls(u), l, mid, func);
        if (func(r) < node[u].func(r)) insert(rs(u), mid + 1, r, func);
    }
    LL query(int u, int l, int r, int x) {
        if (!u) return inf64;
        LL res = node[u].func(x);
        int mid = (l + r) >> 1;
        if (x <= mid) res = std::min(res, query(ls(u), l, mid, x));
        else res = std::min(res, query(rs(u), mid + 1, r, x));
        return res;
    }
};
ST1 st1;
struct ST2 {
    int tree[N << 2];
    int ls(int u) { return u << 1; }
    int rs(int u) { return u << 1 | 1; }
    void clear(int u, int l, int r) {
        tree[u] = 0;
        if (l == r) return;
        int mid = (l + r) >> 1;
        clear(ls(u), l, mid);
        clear(rs(u), mid + 1, r);
    }
    void insert(int u, int l, int r, int x, Func func) {
        st1.insert(tree[u], 0, m, func);
        if (l == r) return;
        int mid = (l + r) >> 1;
        if (x <= mid) insert(ls(u), l, mid, x, func);
        else insert(rs(u), mid + 1, r, x, func);
    }
    LL query(int u, int l, int r, int x, int y, int p) {
        if (x <= l && r <= y) return st1.query(tree[u], 0, m, p);
        LL res = inf64;
        int mid = (l + r) >> 1;
        if (x <= mid) res = std::min(res, query(ls(u), l, mid, x, y, p));
        if (y > mid) res = std::min(res, query(rs(u), mid + 1, r, x, y, p));
        return res;
    }
};
ST2 st2;

LL dis[N], wt[N];
int dep[N], fa[N], size[N], wson[N], top[N], dfc, dfn[N];
void pre_dfs1(int u, int p) {
    size[u] = 1;
    dep[u] = dep[p] + 1;
    for (auto [v, w] : graph[u]) {
        if (v == p) continue;
        wt[v] = w;
        fa[v] = u;
        dis[v] = dis[u] + w;
        pre_dfs1(v, u);
        size[u] += size[v];
        if (size[v] > size[wson[u]]) wson[u] = v;
    }
}
void pre_dfs2(int u, int t) {
    top[u] = t;
    dfn[u] = ++dfc;
    if (wson[u]) pre_dfs2(wson[u], t);
    for (auto [v, w] : graph[u]) {
        if (v == fa[u]) continue;
        if (v == wson[u]) continue;
        pre_dfs2(v, v);
    }
}
int lca(int x, int y) {
    while (top[x] != top[y]) {
        if (dep[top[x]] > dep[top[y]]) std::swap(x, y);
        y = fa[top[y]];
    }
    if (dep[x] > dep[y]) std::swap(x, y);
    return x;
}

std::tuple<int, int, int> e[N]; 
LL ans0[N], ans1[N];
std::vector<std::tuple<int, int, LL>> h[N];

int main() {
    reader.read(n, m, q);
    for (int i = 1; i <= n; i++) reader.read(a[i]);
    for (int i = 1; i < n; i++) {
        int x, y; LL w;
        reader.read(x, y, w);
        graph[x].push_back({y, w});
        graph[y].push_back({x, w});
    }
    pre_dfs1(1, 0);
    pre_dfs2(1, 1);
    for (int i = 1; i <= q; i++) {
        LL u0, u1, v0, v1;
        reader.read(u1, v1);
        u0 = (u1 - 1) / n;
        u1 -= u0 * n;
        v0 = (v1 - 1) / n;
        v1 -= v0 * n;
        int d = std::abs(u0 - v0), p = lca(u1, v1);
        ans0[i] = dis[u1] + dis[v1] - 2 * dis[p];
        ans1[i] = inf64;
        e[i] = {(int)u1, (int)v1, d};
    }
    for (int i = 1; i <= n; i++) {
        st2.insert(1, 1, n, dfn[i], {a[i], 0});
        for (int j = fa[top[i]]; j; j = fa[top[j]])
            st2.insert(1, 1, n, dfn[j], {a[i], 2 * (dis[i] - dis[j])});
    }
    for (int i = 1; i <= q; i++) {
        auto [u1, v1, d] = e[i];
        int p = lca(u1, v1);
        h[p].push_back({i, d, -2 * dis[p]});
        for (int u = u1, t; dep[u] >= dep[p]; u = fa[t]) {
            h[u].push_back({i, d, -2 * dis[u]});
            t = dep[top[u]] > dep[p] ? top[u] : p;
            ans1[i] = std::min(ans1[i], st2.query(1, 1, n, dfn[t], dfn[u], d));
        }
        for (int u = v1, t; dep[u] >= dep[p]; u = fa[t]) {
            h[u].push_back({i, d, -2 * dis[u]});
            t = dep[top[u]] > dep[p] ? top[u] : p;
            ans1[i] = std::min(ans1[i], st2.query(1, 1, n, dfn[t], dfn[u], d));
        }
    }
    st1.tot = 0;
    st2.clear(1, 1, n);
    for (int i = 1; i <= n; i++) {
        st2.insert(1, 1, n, dfn[i], {a[i], -2 * dis[i]});
        for (int j = fa[top[i]]; j; j = fa[top[j]])
            st2.insert(1, 1, n, dfn[j], {a[i], 2 * dis[i] - 4 * dis[j]});
    }
    for (int i = 1; i <= q; i++) {
        auto [u1, v1, d] = e[i];
        int p = lca(u1, v1);
        for (int u = p; u; u = fa[top[u]]) {
            h[u].push_back({i, d, 2 * dis[p] - 4 * dis[u]});
            ans1[i] = std::min(ans1[i], st2.query(1, 1, n, dfn[top[u]], dfn[u], d) + 2 * dis[p]);
        }
    }
    st1.tot = 0;
    st2.clear(1, 1, n);
    for (int i = 1; i <= n; i++) st2.insert(1, 1, n, dfn[i], {a[i], 2 * dis[i]});
    for (int i = 1; i <= n; i++) {
        int l = dfn[i], r = l + size[i] - 1;
        for (auto [id, d, v] : h[i]) ans1[id] = std::min(ans1[id], st2.query(1, 1, n, l, r, d) + v);
    }
    for (int i = 1; i <= q; i++) printf("%lld\n", ans0[i] + ans1[i]);
    return 0;
}