#include <bits/stdc++.h>

#define el '\n'
#define fi first
#define sec second
#define pb push_back
#define int long long
#define pii pair<int,int>
#define sz(v) (int)(v).size()
#define all(v) (v).begin(),(v).end()
#define FOR(i, a, b) for(int i = (a), _b = (b); i <= _b; i++)
#define REP(i, a, b) for(int i = (a), _b = (b); i >= _b; i--)

using namespace std;

const int INF = (int)1e18 + 462010;
const int MAX_VOR = 2e5;
const int MAX_M = 2e5;
const int MAX_N = 1e5;
const int LOG = 18;

struct Disjoint_Set_Union{
    int leader[MAX_VOR + 5];

    void build(int n){
        FOR(i, 1, n) leader[i] = i;
    }

    int get(int u){
        if(u == leader[u]) return u;
        return leader[u] = get(leader[u]);
    }

    void unite(int u, int v){
        int x = get(u), y = get(v);
        if(x == y) return;

        leader[x] = leader[y];
    }
}dsu;

struct Edge{
    int u, v, w;

    bool operator < (const Edge &other) const{
        return w > other.w;
    }
};

struct Query{
    int l, r, t, id;

    bool operator < (const Query &other) const{
        return t < other.t;
    }
};

vector<int> adj[MAX_VOR + 5];
int val[MAX_VOR + 5];
int vor;

Query queries[MAX_M + 5];
int ans[MAX_M + 5];

Edge edges[MAX_M + 5];
pii a[MAX_N + 5];
int n, m, q;

struct Fenwick_Tree{
    int tree[MAX_N + 5];

    void update(int pos, int val){
        for(int i = pos; i <= n; i += i & -i) tree[i] += val;
    }

    int get(int pos){
        int res = 0;
        for(int i = pos; i >= 1; i -= i & -i) res += tree[i];
        return res;
    }

    int query(int l, int r){
        return get(r) - get(l - 1);
    }
}fen;

void Input(){
    cin >> n >> m >> q;

    FOR(i, 1, m){
        int u, v, w;
        cin >> u >> v >> w;
        edges[i] = {u, v, w};
    }

    FOR(i, 1, n){
        cin >> a[i].fi;
        a[i].sec = i;
    }
    sort(a + 1, a + n + 1);
}

void kruskal(){
    sort(edges + 1, edges + m + 1);
    dsu.build(MAX_VOR);
    vor = n;

    FOR(i, 1, m){
        int u = edges[i].u, v = edges[i].v;
        int w = edges[i].w;

        int x = dsu.get(u), y = dsu.get(v);
        if(x != y){
            ++vor;
            val[vor] = w;

            adj[vor].pb(x);
            adj[vor].pb(y);

            dsu.unite(x, vor);
            dsu.unite(y, vor);
        }
    }
}

namespace LCA{
    int par[LOG + 5][MAX_VOR + 5], depth[MAX_VOR + 5];
    int L[MAX_VOR + 5], R[MAX_VOR + 5], timer;

    void dfs_lca(int u, int dad){
        if(u <= n) L[u] = R[u] = ++timer;
        else L[u] = INF, R[u] = -INF;

        for(int v : adj[u]) if(v != dad){
            depth[v] = depth[u] + 1;
            par[0][v] = u;

            dfs_lca(v, u);

            L[u] = min(L[u], L[v]);
            R[u] = max(R[u], R[v]);
        }
    }

    void build_lca(int n){
        REP(u, n, 1) if(!depth[u]){
            dfs_lca(u, 0);
        }

        FOR(j, 1, LOG) FOR(i, 1, n){
            par[j][i] = par[j - 1][par[j - 1][i]];
        }
    }

    pii get_LR(int u, int w){
        REP(j, LOG, 0) if(val[par[j][u]] >= w){
            u = par[j][u];
        }

        return {L[u], R[u]};
    }
} using namespace LCA;

void Prepare(){
    kruskal();
    build_lca(vor);
}

void Solve(){
    FOR(i, 1, q){
        int u, w, t;
        cin >> u >> w >> t;

        pii cur = get_LR(u, w);
        queries[i] = {cur.fi, cur.sec, t, i};
    }
    sort(queries + 1, queries + q + 1);

    for(int i = 1, j = 1; i <= q; i++){
        int l = queries[i].l, r = queries[i].r;
        int t = queries[i].t, id = queries[i].id;

        while(j <= n && a[j].fi <= t) fen.update(L[a[j++].sec], +1);
        ans[id] = fen.query(l, r);
    }

    FOR(i, 1, q) cout << ans[i] << el;
}

signed main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    Input();
    Prepare();
    Solve();

    return 0;
}