#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, d;
    Node(int a = 0, int b = 0) {id = a; d = b;}
};
struct NOde {
    int id, l, r, d;
    NOde(int a = 0, int b = 0, int c = 0, int D = 0) {id = a; l = b; r = c; d = D;}
};
struct NODe {
    int id, d, x;
    NODe(int a = 0, int b = 0, int c = 0) {id = a; d = b; x = c;}
};
int n, m, T, a[N];
int depth[N], fa[N], sz[N], son[N], id[N], num, top[N];
ll dis[N], now[N], ans[N], len[N];
vector< pair<int, ll> > g[N];
vector<Node> mem[N], vec[N];
vector<NODe> fuc[N];
vector<NOde> ex[N];
struct LC_Segment_Tree {
    struct node {
        int ls, rs, k; ll b;
        node() {ls = rs = k = 0; b = INF;}
    }t[N * 20];
    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[tot].k = k; t[tot].b = b;
            return;
        }
        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;
        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;
    }
}t;
struct Segment_Tree {
    #define ls (rt << 1)
    #define rs (rt << 1 | 1)

    int root[N << 2];

    void update(int rt, int l, int r, int pos, int k, ll b) {
        t.update(root[rt], 0, inf, k, b);
        if (l == r) return;
        int mid = (l + r) >> 1;
        if (pos <= mid) update(ls, l, mid, pos, k, b);
        else update(rs, mid + 1, r, pos, k, b);
    }

    ll query(int rt, int l, int r, int ql, int qr, int x) {
        if (ql <= l && r <= qr) return t.query(root[rt], 0, inf, x);
        int mid = (l + r) >> 1; ll res = INF;
        if (ql <= mid) res = min(res, query(ls, l, mid, ql, qr, x));
        if (qr > mid) res = min(res, query(rs, mid + 1, r, ql, qr, x));
        return res;
    }

    void build(int rt, int l, int r) {
        root[rt] = 0;
        if (l == r) return;
        int mid = (l + r) >> 1;
        build(ls, l, mid); build(rs, mid + 1, r);
    }

    void init(int l, int r) {
        build(1, l, r);
        t.init();
    }

    #undef ls
    #undef rs
}tt;

void dfs1(int x, int pa, int d) {
    depth[x] = d; fa[x] = pa; sz[x] = 1;
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (y == pa) continue;
        dis[y] = dis[x] + tmp.second;
        dfs1(y, x, d + 1);
        sz[x] += sz[y];
        if (sz[y] > sz[son[x]]) son[x] = y;
    }
}

void dfs2(int x, int anc) {
    id[x] = ++num; top[x] = anc;
    if (son[x]) dfs2(son[x], anc);
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (y == fa[x] || y == son[x]) continue;
        dfs2(y, y);
    }
}

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

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

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

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

void UPdate(int x, int anc) {
    t.update(t.fir, 0, inf, a[x], (dis[x] - dis[anc] - dis[anc]) * 2);
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (y == fa[x]) continue;
        UPdate(y, anc);
    }
}

void dfs5(int x) {
    t.update(t.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]) continue;
        UPdate(y, x);
    }
    for (auto tmp : fuc[x]) ans[tmp.id] = min(ans[tmp.id], t.query(t.fir, 0, inf, tmp.d) + dis[tmp.x] + dis[tmp.x]);
    if (son[x]) dfs5(son[x]);
    else t.init();
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (y == fa[x] || y == son[x]) continue;
        dfs5(y);
    }
}

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

void dfs6(int x) {
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (y == fa[x] || y == son[x]) continue;
        dfs6(y); t.init();
    }
    if (son[x]) dfs6(son[x]);
    t.update(t.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]) continue;
        UPDate(y);
    }
    for (auto tmp : fuc[x]) ans[tmp.id] = min(ans[tmp.id], t.query(t.fir, 0, inf, tmp.d) + (dis[tmp.x] << 1) - (dis[x] << 2));
}

void Update(int x, int L, int R, int anc) {
    tt.update(1, L, R, id[anc], a[x], (dis[x] - dis[anc]) << 1);
    for (auto tmp : g[x]) {
        int y = tmp.first;
        if (y == fa[x]) continue;
        Update(y, L, R, anc);
    }
}

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));
    }
    dfs1(1, 1, 1); dfs2(1, 1);
    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;
        int fx = x, fy = y;
        while (top[fx] != top[fy]) {
            if (depth[top[fx]] < depth[top[fy]]) swap(fx, fy);
            mem[fx].push_back(Node(i, d));
            fx = fa[top[fx]];
        }
        if (id[fx] > id[fy]) swap(fx, fy);
        if (fx == top[fx]) mem[fy].push_back(Node(i, d));
        else {
            ex[top[fx]].push_back(NOde(i, id[fx], id[fy], d));
            vec[fy].push_back(Node(i, d));
        }
        len[i] = dis[x] + dis[y] - dis[fx] - dis[fx];
        ans[i] = INF;
        int uuu = fx;
        fuc[fx].push_back(NODe(i, d, uuu));
        while (top[fx] != 1) {
            fx = fa[top[fx]];
            fuc[fx].push_back(NODe(i, d, uuu));
        }
    }
    dfs3(1); t.init(); dfs4(1); dfs5(1); dfs6(1); t.init();
    for (int i = 1, x, L, R; i <= n; ++i) {
        if (ex[i].empty()) continue;
        x = i;
        while (son[x]) x = son[x];
        tt.init(L = id[i], R = id[x]);
        x = i;
        while (x) {
            tt.update(1, L, R, id[x], a[x], 0);
            for (auto tmp : g[x]) {
                int y = tmp.first;
                if (y == fa[x] || y == son[x]) continue;
                Update(y, L, R, x);
            }
            x = son[x];
        }
        for (auto tmp : ex[i]) ans[tmp.id] = min(ans[tmp.id], tt.query(1, L, R, tmp.l, tmp.r, tmp.d));
    }
    for (int i = 1; i <= T; ++i) printf("%d %lld\n", i, ans[i] + len[i]);
    return 0;
}