import sys

input = sys.stdin.readline


class DSU:
    def __init__(self, n):
        self.p = [-1] * n

    def leader(self, x):
        while self.p[x] >= 0:
            if self.p[self.p[x]] >= 0:
                self.p[x] = self.p[self.p[x]]
            x = self.p[x]
        return x

    def merge(self, a, b):
        a = self.leader(a)
        b = self.leader(b)
        if a == b:
            return a
        if -self.p[a] < -self.p[b]:
            a, b = b, a
        self.p[a] += self.p[b]
        self.p[b] = a
        return a


n, m, q = map(int, input().split())
a = list(map(int, input().split()))
g = []
for _ in range(m):
    u, v, w = map(int, input().split())
    g.append((w, u - 1, v - 1))
g.sort()
p = [-1] * (2 * n)
cnt = [1] * (2 * n)
root = list(range(n))
w = [0] * (2 * n)
d = [{a[i]} for i in range(n)]
dsu = DSU(n)
k = n
for cost, u, v in g:
    u = dsu.leader(u)
    v = dsu.leader(v)
    if u == v:
        continue
    x = root[u]
    y = root[v]
    p[x] = k
    p[y] = k
    w[k] = cost
    if len(d[u]) > len(d[v]):
        u, v = v, u
    d[v].update(d[u])
    d[u].clear()
    r = dsu.merge(u, v)
    if r == u:
        d[u], d[v] = d[v], d[u]
    root[r] = k
    cnt[k] = len(d[r])
    k += 1
rt = [0] * n
for i in range(n):
    rt[i] = root[dsu.leader(i)]
LOG = k.bit_length()
up = [[-1] * k for _ in range(LOG)]
for i in range(k):
    up[0][i] = p[i]
for j in range(1, LOG):
    prev = up[j - 1]
    cur = up[j]
    for i in range(k):
        x = prev[i]
        if x != -1:
            cur[i] = prev[x]
ans = []
for _ in range(q):
    s, c = map(int, input().split())
    s -= 1
    if cnt[rt[s]] < c:
        print(-1)
        continue
    if c <= 1:
        print(0)
        continue
    x = s
    for j in range(LOG - 1, -1, -1):
        y = up[j][x]
        if y != -1 and cnt[y] < c:
            x = y
    print(w[p[x]])