#include <cstdio>

#include <cstring>

#include <algorithm>

using namespace std;

const int N = 1e5 + ;

const int M = 5e5 + ;

const int inf =  << ;

int n, m, qn, a[N], mn = , mp[N], ufs[N], siz[N];

struct Innum {

    int val, id;

    friend bool operator < (const Innum &x, const Innum &y) {

        if(x.val == y.val) return x.id < y.id;

        else return x.val < y.val;

    }

} in[N];

struct Pathway {

    int u, v, val;

    friend bool operator < (const Pathway &x, const Pathway &y) {

        return x.val < y.val;

    }

} path[M];

struct Querys {

    int pos, val, k, id, res;

    friend bool operator < (const Querys &x, const Querys &y) {

        return x.val < y.val;

    }

} q[M];

inline void read(int &X) {

    X = ; char ch = ; int op = ;

    for(; ch > '' || ch < ''; ch = getchar())

        if(ch == '-') op = -;

    for(; ch >= '' && ch <= ''; ch = getchar())

        X = (X << ) + (X << ) + ch - ;

    X *= op;

}

inline void chkMax(int &x, int y) {

    if(y > x) x = y;

}

inline void discrete() {

    sort(in + , in +  + n);

    in[].val = -inf;

    for(int cnt = , i = ; i <= n; i++)  {

        if(in[i].val != in[i - ].val) ++cnt;

        chkMax(mn, cnt);

        a[in[i].id] = cnt;

        mp[cnt] = in[i].val;

    }

} 

namespace PSegT {

    struct Node {

        int lc, rc, sum;

    } s[N * ];

    int root[N], nodeCnt = , top = , pool[N * ];

    #define lc(p) s[p].lc

    #define rc(p) s[p].rc

    #define sum(p) s[p].sum

    #define mid ((l + r) >> 1) 

    inline void push(int x) {

        pool[++top] = x;

    }

    inline int newNode() {

        if(top) return pool[top--];

        else return ++nodeCnt;

    }

    void ins(int &p, int l, int r, int x) {

        if(!p) p = newNode();

        ++sum(p);

        if(l == r) return;

        if(x <= mid) ins(lc(p), l, mid, x);

        else  ins(rc(p), mid + , r, x);

    }

    int go(int p, int l, int r, int x) {

        if(l == r) return sum(p);

        if(x <= mid) return go(lc(p), l, mid, x);

        else return go(rc(p), mid + , r, x);

    }

    int query(int p, int l, int r, int k)  {

        if(l == r) return mp[l];

        int now = sum(lc(p));

        if(k <= now) return query(lc(p), l, mid, k);

        else return query(rc(p), mid + , r, k - now);

    }

    int merge(int u, int v, int l, int r) {

        if(!u || !v) return u + v;

        int p = newNode();

        if(l == r) sum(p) = sum(u) + sum(v);

        else {

            lc(p) = merge(lc(u), lc(v), l, mid);

            rc(p) = merge(rc(u), rc(v), mid + , r);

            sum(p) = sum(lc(p)) + sum(rc(p));

        }

        push(u), push(v);

        return p;

    }

} using namespace PSegT;

inline void init() {

    for(int i = ; i <= n; i++) {

        ufs[i] = i;

        siz[i] = ;

        ins(root[i], , mn, a[i]);

    }

}

int find(int x) {

    return ufs[x] == x ? x : ufs[x] = find(ufs[x]);

}

inline void merge(int x, int y) {

    int fx = find(x), fy = find(y);

    if(fx == fy) return;

    root[fx] = merge(root[fx], root[fy], , mn);

    ufs[fy] = fx;

    siz[fx] += siz[fy];

/*    for(int i = 1; i <= mn; i++)

        printf("%d ", go(root[fx], 1, mn, i));

    printf("\n");    */

}

int main()  {

    read(n), read(m), read(qn);

    for(int i = ; i <= n; i++) {

        read(a[i]);

        in[i].val = a[i], in[i].id = i;

    }

    for(int i = ; i <= m; i++)

        read(path[i].u), read(path[i].v), read(path[i].val);

    for(int i = ; i <= qn; i++)

        read(q[i].pos), read(q[i].val), read(q[i].k), q[i].id = i;

    sort(path + , path +  + m), sort(q + , q +  + qn);

/*    printf("\n");

    for(int i = 1; i <= m; i++)

        printf("%d %d %d\n", path[i].u, path[i].v, path[i].val);

    printf("\n");

    for(int i = 1; i <= qn; i++)

        printf("%d %d %d\n", q[i].pos, q[i].val, q[i].k);

    printf("\n");      */

    discrete();

    init();

/*    for(int i = 1; i <= n; i++)

        printf("%d ", a[i]);

    printf("\n");    */

    for(int j = , i = ; i <= qn; i++) {

        for(; j <= m && path[j].val <= q[i].val; ++j)

            merge(path[j].u, path[j].v);

        int now = find(q[i].pos);

/*        for(int k = 1; k <= mn; k++)

            printf("%d ", go(root[now], 1, mn, k));

        printf("\n");     */

        if(q[i].k > siz[now]) q[q[i].id].res = -;

        else q[q[i].id].res = query(root[now], , mn, siz[now] - q[i].k + );

    }

    for(int i = ; i <= qn; i++)

        printf("%d\n", q[i].res);

    return ;

}