#include <bits/stdc++.h>
#define pii pair <int , int>
#define pll pair <LL , LL>
#define mp make_pair
#define fs first
#define sc second
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;

//const int Mxdt=100000;
//static char buf[Mxdt],*p1=buf,*p2=buf;
//#define getchar() p1==p2&&(p2=(p1=buf)+fread(buf,1,Mxdt,stdin),p1==p2)?EOF:*p1++;

template <typename T>
void read(T &x) {
	T f=1;x=0;char s=getchar();
	while(s<'0'||s>'9') {if(s=='-') f=-1;s=getchar();}
	while(s>='0'&&s<='9') {x=(x<<3)+(x<<1)+(s^'0');s=getchar();}
	x *= f;
}

template <typename T>
void write(T x , char s='\n') {
	if(!x) {putchar('0');putchar(s);return;}
	if(x<0) {putchar('-');x=-x;}
	T t = 0 , tmp[25] = {};
	while(x) tmp[t ++] = x % 10 , x /= 10;
	while(t -- > 0) putchar(tmp[t] + '0');
	putchar(s);
}

const int MAXN = 2e5 + 5;

int rt , ls[MAXN * 20] , rs[MAXN * 20] , num , n , m , q;
LL K[MAXN * 20] , B[MAXN * 20];

void Ins(int l , int r , int &now , LL k , LL b) {
	if(!now) {
		now = ++num;
		K[now] = k , B[now] = b;
		return;
	}
	
	LL Lval = K[now] * l + B[now] , Rval = K[now] * r + B[now];
	LL lv = k * l + b , rv = k * r + b;
	
	if(Lval <= lv && Rval <= rv) return;
	if(Lval >= lv && Rval >= rv) return;
	
	int mid = (l + r) >> 1;
	
	LL Mval = mid * K[now] + B[now];
	LL mv = mid * k + b;
	if(Mval <= mv) {
		if(Lval <= lv) Ins(mid + 1 , r , rs[now] , k , b);
		else Ins(l , mid , ls[now] , k , b);
	}
	else {
		swap(K[now] , k) , swap(B[now] , b);
		if(lv <= Lval) Ins(mid + 1 , r , rs[now] , k , b);
		else Ins(l , mid , ls[now] , k , b);
	}
}

LL find(int l , int r , int now , int x) {
	if(!now) return 1e18;
	LL res = K[now] * x + B[now];
	if(l == r) return res;
	int mid = (l + r) >> 1;
	if(x <= mid) res = min(res , find(l , mid , ls[now] , x));
	else res = min(res , find(mid + 1 , r , rs[now] , x));
	return res;
}

void clear(int l , int r , int now) {
	if(!now) return;
	int mid = (l + r) >> 1;
	clear(l , mid , ls[now]);
	clear(mid + 1 , r , rs[now]);
	ls[now] = rs[now] = 0;
}

vector <pii> G[MAXN];

int siz[MAXN] , hson[MAXN] , dep[MAXN];
LL dis[MAXN] , hv[MAXN];

void dfs1(int x , int fa) {
	siz[x] = 1;dep[x] = dep[fa] + 1;
	for (auto v:G[x]) {
		if(v.fs == fa) continue;
		dis[v.fs] = dis[x] + v.sc;
		dfs1(v.fs , x);
		siz[x] += siz[v.fs];
		if(siz[v.fs] > siz[hson[x]]) hson[x] = v.fs , hv[x] = v.sc;
	}
}

int top[MAXN] , Num , dfn[MAXN] , f[MAXN] , bot[MAXN] , rf[MAXN];

void dfs2(int x , int fa , int tp) {
	dfn[x] = ++Num;f[x] = fa;rf[Num] = x;
	top[x] = tp;bot[tp] = x;
	if(hson[x]) dfs2(hson[x] , x , tp);
	for (auto v:G[x]) {
		if(v.fs == fa || v.fs == hson[x]) continue;
		dfs2(v.fs , x , v.fs);
	}
}

int LCA(int x , int y) {
	while(top[x] != top[y]) {
		if(dep[top[x]] < dep[top[y]]) swap(x , y);
		x = f[top[x]];
	}
	if(dep[x] > dep[y]) swap(x , y);
	return x;
}

LL Ans[MAXN] , a[MAXN];

namespace For_LCA {
	int siz[MAXN] , mx , Rt , vis[MAXN];
	vector <pii> Q[MAXN];
	
	void find_root(int x , int fa , int Tot) {
		siz[x] = 1;
		int cur = 0;
		for (auto v:G[x]) {
			if(v.fs == fa || vis[v.fs]) continue;
			find_root(v.fs , x , Tot);
			siz[x] += siz[v.fs];
			cur = max(cur , siz[v.fs]);
		}
		cur = max(cur , Tot - siz[x]);
		if(cur < mx) mx = cur , Rt = x;
	}
	
	void dfs(int x , int fa , LL d) {
		Ins(0 , m , rt , a[x] , d * 2);
		for (auto v:G[x]) {
			if(v.fs == fa || vis[v.fs]) continue;
			dfs(v.fs , x , d + v.sc);
		}
	}
	
	void calc(int x , int fa , LL d) {
		
		for (auto v:Q[x]) {
			Ans[v.sc] = min(Ans[v.sc] , find(0 , m , rt , v.fs) + d * 2);
		}
		
		for (auto v:G[x]) {
			if(v.fs == fa || vis[v.fs]) continue;
			calc(v.fs , x , d + v.sc);
		}
	}
	
	void work(int x) {
		mx = Rt = 1e9;
		find_root(x , 0 , n);
		mx = Rt = 1e9;
		find_root(x , 0 , siz[x]);
		x = Rt;vis[x] = 1;
		
		dfs(x , 0 , 0);
		calc(x , 0 , 0);
		clear(0 , m , rt);
		num = rt = 0;
		
		for (auto v:G[x]) if(!vis[v.fs]) {
			work(v.fs);
		}
	}
}

namespace SubTree {
	vector <pair <pii , LL> > Q[MAXN];
	
	void calc(int x , int fa , int hs) {
		Ins(0 , m , rt , a[x] , dis[x] * 2);
		for (auto v:G[x]) {
			if(v.fs == fa || v.fs == hs) continue;
			calc(v.fs , x , hs);
		}
	}
	
	void dfs(int x , int fa , int op) {
		for (auto v:G[x]) {
			if(v.fs == fa || v.fs == hson[x]) continue;
			dfs(v.fs , x , 0);
		}
		if(hson[x]) dfs(hson[x] , x , 1);
		calc(x , fa , hson[x]);
		
		for (auto v:Q[x]) {
			Ans[v.fs.fs] = min(Ans[v.fs.fs] , find(0 , m , rt , v.fs.sc) - dis[x] * 2 + v.sc);
		}
		
		if(!op) clear(0 , m , rt) , num = rt = 0;
	}
	
}

namespace Divide {
	
	vector <pair <int , pii> > LQ[MAXN] , RQ[MAXN];
	
	void Add(int x , int gl , int id , int d) {
		SubTree::Q[x].push_back(mp(mp(id , d) , 0));
		while(top[x] != top[gl]) {
			LQ[dfn[top[x]]].push_back(mp(dfn[x] , mp(id , d)));
			RQ[dfn[x]].push_back(mp(dfn[top[x]] , mp(id , d)));
			x = f[top[x]];
			SubTree::Q[hson[x]].push_back(mp(mp(id , d) , hv[x] * 2));
		}
		if(x != gl) {
			LQ[dfn[gl] + 1].push_back(mp(dfn[x] , mp(id , d)));
			LQ[dfn[x]].push_back(mp(dfn[gl] + 1 , mp(id , d)));
		}
	}
	
	void dfs(int x , int fa , LL s) {
		Ins(0 , m , rt , a[x] , (dis[x] - s) * 2);
		for (auto v:G[x]) {
			if(v.fs == fa) continue;
			dfs(v.fs , x , s);
		}
	}
	
	void solve(int l , int r) { 
		if(l == r) {
			if(!LQ[l].size()) return;
			return;
		}
	
		int mid = (l + r) >> 1;
		
		for (int i = mid; i >= l; --i) {
			int x = rf[i];
			for (auto v:G[x]) {
				if(v.fs == hson[x] || v.fs == f[x]) continue;
				dfs(v.fs , x , dis[x]);
			}
			
			while(LQ[i].size()) {
				auto cur = (*LQ[i].rbegin());
				if(cur.fs > mid) Ans[cur.sc.fs] = min(Ans[cur.sc.fs] , find(0 , m , rt , cur.sc.sc));
				LQ[i].pop_back();
			}
		}
		clear(0 , m , rt);num = rt = 0;
		
		for (int i = mid + 1; i <= r; ++i) {
			int x = rf[i];
			for (auto v:G[x]) {
				if(v.fs == hson[x] || v.fs == f[x]) continue;
				dfs(v.fs , x , dis[x]);
			}
			
			while(RQ[i].size()) {
				auto cur = (*RQ[i].rbegin());
				if(cur.fs <= mid) Ans[cur.sc.fs] = min(Ans[cur.sc.fs] , find(0 , m , rt , cur.sc.sc));
				RQ[i].pop_back();
			}
		}
		clear(0 , m , rt);num = rt = 0;
		
		solve(l , mid) , solve(mid + 1 , r);
		
	}
	
	void calc() {
		for (int i = 1; i <= n; ++i) {
			sort(LQ[i].begin() , LQ[i].end());
			sort(RQ[i].begin() , RQ[i].end() , [&] (pair <int , pii> x , pair <int , pii> y) {return x > y;});
		}
		
		for (int i = 1; i <= n; ++i) if(top[i] == i) {
			solve(dfn[i] , dfn[bot[i]]);
		}
		
	}
}

LL Bas[MAXN];

int main() {
	read(n),read(m),read(q);
	for (int i = 1; i <= n; ++i) read(a[i]);
	
	for (int i = 1; i < n; ++i) {
		int u , v , w;
		read(u),read(v),read(w);
		G[u].push_back(mp(v , w));
		G[v].push_back(mp(u , w));
	}
	
	dfs1(1 , 0);
	dfs2(1 , 0 , 1);
	
	for (int i = 1; i <= q; ++i) {
		int s , t;
		read(s),read(t);
		int d = (t - 1) / n - (s - 1) / n;
		if(d < 0) d = -d;
		s = (s - 1) % n + 1 , t = (t - 1) % n + 1;
		int lca = LCA(s , t);
		Bas[i] = dis[s] + dis[t] - dis[lca] * 2;
		For_LCA::Q[lca].push_back(mp(d , i));
		Divide::Add(s , lca , i , d);
		Divide::Add(t , lca , i , d);
		Ans[i] = 1e18;
	}
	
	For_LCA::work(1);
	SubTree::dfs(1 , 0 , 0);
	Divide::calc();
	
	for (int i = 1; i <= q; ++i) write(Bas[i] + Ans[i]);
	
	return 0;
}