#include<bits/stdc++.h>
#define ll long long
#define i128 __int128
#define For(i,a,b) for(int i=(a);i<=(b);++i)
#define Rof(i,a,b) for(int i=(a);i>=(b);--i)
using namespace std;
const int Maxn=2e5,lim=1e9;
const ll inf=8e18;

int n,m,q,a[Maxn+5]; ll ans[Maxn+5],dis[Maxn+5],dxv[Maxn+5];
int fa[Maxn+5],dfn[Maxn+5],st[Maxn+5][20],dx[Maxn+5],cur;
int siz[Maxn+5],dep[Maxn+5],son[Maxn+5],top[Maxn+5];
vector<pair<int,ll>> v[Maxn+5],w[Maxn+5],w2[Maxn+5];
vector<array<int,3>> qr[Maxn+5]; vector<int> w1[Maxn+5];
struct Line{int k; ll b; inline ll F(int x){return 1ll*k*x+b;}};
inline Line operator-(Line x,Line y) {return Line{x.k-y.k,x.b-y.b};}
inline bool operator<(Line x,Line y) {return x.k<y.k || (x.k==y.k && x.b<y.b);}
inline i128 operator*(Line x,Line y) {return (i128)x.k*y.b-(i128)y.k*x.b;}
inline bool chk(Line x,Line y,int k) {return (y.b-x.b)<=1ll*k*(y.k-x.k);}
struct Node{int l,r; Line k;};
struct LCT
{
    Node t[Maxn*200+5]; int tot,tmp;
    #define ls(x) t[x].l
    #define rs(x) t[x].r
    inline void Insert(int &p,int l,int r,Line k)
    {
        if(!p) {t[p=++tot]=Node{0,0,k}; return;}
        int mid=(l+r)>>1; if(t[p].k.F(mid)>k.F(mid)) swap(t[p].k,k);
        if(k.F(l)<t[p].k.F(l)) Insert(ls(p),l,mid,k);
        if(k.F(r)<t[p].k.F(r)) Insert(rs(p),mid+1,r,k);
    }
    inline ll Find(int p,int l,int r,int x)
    {
        if(!p) return inf; if(l==r) return t[p].k.F(x); int mid=(l+r)>>1;
        return min(t[p].k.F(x),(x<=mid)?Find(ls(p),l,mid,x):Find(rs(p),mid+1,r,x));
    }
    #undef ls
    #undef rs
} T;

inline int GetID(int x,int y) {return dfn[x]<dfn[y]?x:y;}
inline int LCA(int x,int y)
{
    if(x==y) return x; if((x=dfn[x])>(y=dfn[y])) swap(x,y);
    int len=__lg(y-x++); return GetID(st[x][len],st[y-(1<<len)+1][len]);
}
inline ll Dis(int x,int y) {return dis[x]+dis[y]-2*dis[LCA(x,y)];}
inline void dfs1(int x,int f)
{
    fa[x]=f,dep[x]=dep[f]+1,siz[x]=1;
    for(auto [y,z]:v[x]) if(y!=f)
    {
        dis[y]=dis[x]+z,dfs1(y,x),siz[x]+=siz[y];
        if(siz[y]>siz[son[x]]) son[x]=y;
    }
}
inline void dfs2(int x,int t)
{
    dfn[x]=++cur,st[cur][0]=fa[x],top[x]=t;
    if(son[x]) dfs2(son[x],t);
    for(auto [y,z]:v[x]) if(y!=fa[x] && y!=son[x]) dfs2(y,y);
}
inline void Work(int x,int y,int id)
{
    while(top[x]!=top[y]) w[x].emplace_back(id,0ll),w1[x].push_back(id),x=fa[top[x]];
    qr[top[y]].push_back({y,x,id});
}
inline void Upd(int x,int id)
{
    for(int i=x;i;i=fa[top[i]])
        w[i].emplace_back(id,dis[x]-dis[i]),w2[i].emplace_back(id,dis[x]-dis[i]);
}
namespace DSU
{
    int rt;
    inline void Add(int x) {T.Insert(rt,0,lim,Line{a[x],dis[x]});}
    inline void dfs2(int x) {Add(x); for(auto [y,z]:v[x]) if(y!=fa[x]) dfs2(y);}
    inline void dfs1(int x,int tp)
    {
        for(auto [y,z]:v[x]) if(y!=fa[x] && y!=son[x]) dfs1(y,0);
        if(son[x]) dfs1(son[x],1); Add(x);
        for(auto [y,z]:v[x]) if(y!=fa[x] && y!=son[x]) dfs2(y);
        if(!w[x].empty()) for(auto [id,z]:w[x])
            ans[id]=min(ans[id],T.Find(rt,0,lim,dx[id])-dis[x]+z);
        if(!tp) rt=T.tot=0;
    }
}
struct Polygon
{
    vector<Line> v;
    inline void Add(Line k)
    {
        while(v.size()>1)
        {
            if((k-v.back())*(v.back()-v[v.size()-2])>=0) v.pop_back();
            else break;
        } v.push_back(k);
    }
    inline ll Get(int k)
    {
        int sz=v.size(),l=0,r=sz-1; while(l<r)
        {
            int mid=(l+r)/2;
            if(chk(v[mid],v[mid+1],k)) l=mid+1; else r=mid;
        } return v[l].F(-k);
    }
    inline void Clear() {vector<Line>().swap(v);}
};
struct SegTree
{
    Polygon t[Maxn*4+5];
    #define ls(x) (x<<1)
    #define rs(x) (x<<1|1)
    inline void Build(int l,int r,int p)
    {
        t[p].Clear(); if(l==r) return;
        int mid=(l+r)>>1; Build(l,mid,ls(p)),Build(mid+1,r,rs(p));
    }
    inline void Insert(int l,int r,int p,int pos,Line k)
    {
        t[p].Add(k); if(l==r) return; int mid=(l+r)>>1;
        if(pos<=mid) Insert(l,mid,ls(p),pos,k); else Insert(mid+1,r,rs(p),pos,k);
    }
    inline ll Count(int nl,int nr,int l,int r,int p,int k)
    {
        if(l<=nl && nr<=r) return t[p].Get(k);
        int mid=(nl+nr)>>1; ll res=inf;
        if(l<=mid) res=min(res,Count(nl,mid,l,r,ls(p),k));
        if(r>mid) res=min(res,Count(mid+1,nr,l,r,rs(p),k));
        return res;
    }
    #undef ls
    #undef rs
} Tr;
namespace Chain
{
    int r1,r2; vector<pair<Line,int>> vx;
    inline void Add(int x,ll k1,ll k2,int id)
    {
        vx.emplace_back(Line{-a[x],k1},id);
        T.Insert(r1,0,lim,Line{a[x],k1}),T.Insert(r2,0,lim,Line{a[x],k2});
    }
    inline void dfs1(int x,ll k1,ll k2,int id) {Add(x,k1,k2,id); for(auto [y,z]:v[x]) if(y!=fa[x]) dfs1(y,k1+z,k2+z,id);}
    inline void dfs(int x)
    {
        static int st[Maxn+5]; int top=0; r1=0,r2=0,T.tot=0;
        for(int i=x;i;i=son[i]) st[++top]=i; int lw=st[top];
        vector<pair<Line,int>>().swap(vx);
        For(_,1,top)
        {
            int i=st[_]; Add(i,0ll,dis[lw]-dis[i],_);
            for(auto [j,z]:v[i]) if(j!=fa[i] && j!=son[i]) dfs1(j,z,dis[lw]-dis[i]+z,_);
            for(auto id:w1[i]) ans[id]=min(ans[id],T.Find(r1,0,lim,dx[id]));
            for(auto [id,z]:w2[i]) ans[id]=min(ans[id],T.Find(r2,0,lim,dx[id])+z-(dis[lw]-dis[i]));
        }
        sort(vx.begin(),vx.end()); Tr.Build(1,top,1);
        for(auto [k,i]:vx) Tr.Insert(1,top,1,i,k);
        for(auto [l,r,id]:qr[x])
        {
            l=dfn[l]-dfn[x]+1,r=dfn[r]-dfn[x]+1;
            ans[id]=min(ans[id],Tr.Count(1,top,l,r,1,dx[id]));
        }
        for(int i=x;i;i=son[i]) for(auto [j,z]:v[i])
            if(j!=fa[i] && j!=son[i]) dfs(j);
    }
}

int main()
{
    // freopen("1.in","r",stdin);

    cin>>n>>m>>q;
    For(i,1,n) cin>>a[i];
    For(i,1,n-1)
    {
        int a,b; ll c; cin>>a>>b>>c; c*=2;
        v[a].emplace_back(b,c),v[b].emplace_back(a,c);
    }
    dfs1(1,0),dfs2(1,1);
    For(j,1,19) for(int i=1;i+(1<<j)-1<=n;++i)
        st[i][j]=GetID(st[i][j-1],st[i+(1<<j-1)][j-1]);
    For(i,1,q)
    {
        ll s,t; cin>>s>>t;
        int p=(s-1)/n,x=s-1ll*p*n,q=(t-1)/n,y=t-1ll*q*n,l=LCA(x,y);
        ans[i]=inf,dx[i]=abs(p-q),dxv[i]=Dis(x,y)/2;
        if(x!=l) Work(x,l,i); if(y!=l) Work(y,l,i); Upd(l,i);
    }
    DSU::dfs1(1,1); Chain::dfs(1);
    For(i,1,q) printf("%lld\n",ans[i]+dxv[i]);
    return 0;
}