#include <bits/stdc++.h>
using namespace std;
using ll = long long;
static const ll INF = (ll)4e18;

struct Edge {
    int to;
    ll cap;
    int rev;
};

struct Dinic {
    int N;
    vector<vector<Edge>> G;
    vector<int> level, ptr;
    Dinic(int n) : N(n), G(n), level(n), ptr(n) {}

    void add_edge(int u, int v, ll c) {
        G[u].push_back({v, c, (int)G[v].size()});
        G[v].push_back({u, 0, (int)G[u].size() - 1});
    }

    bool bfs(int s, int t) {
        fill(level.begin(), level.end(), -1);
        queue<int> q;
        level[s] = 0;
        q.push(s);
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            for (auto &e : G[u]) {
                if (level[e.to] < 0 && e.cap > 0) {
                    level[e.to] = level[u] + 1;
                    q.push(e.to);
                }
            }
        }
        return level[t] >= 0;
    }

    ll dfs(int u, int t, ll f) {
        if (u == t) return f;
        for (int &i = ptr[u]; i < (int)G[u].size(); i++) {
            Edge &e = G[u][i];
            if (e.cap > 0 && level[e.to] == level[u] + 1) {
                ll pushed = dfs(e.to, t, min(f, e.cap));
                if (pushed > 0) {
                    e.cap -= pushed;
                    G[e.to][e.rev].cap += pushed;
                    return pushed;
                }
            }
        }
        return 0;
    }

    ll max_flow(int s, int t) {
        ll flow = 0;
        while (bfs(s, t)) {
            fill(ptr.begin(), ptr.end(), 0);
            while (true) {
                ll pushed = dfs(s, t, INF);
                if (pushed == 0) break;
                flow += pushed;
            }
        }
        return flow;
    }
};

int main() {
    int N;
    cin >> N;
    vector<ll> P(N);
    for (int i = 0; i < N; i++) cin >> P[i];
    int M;
    cin >> M;
    vector<pair<int, int>> deps(M);
    for (int i = 0; i < M; i++) {
        cin >> deps[i].first >> deps[i].second;
        --deps[i].first;
        --deps[i].second;
    }
    int K;
    cin >> K;
    vector<tuple<int, int, ll>> syn(K);
    for (int j = 0; j < K; j++) {
        int A, B;
        ll S;
        cin >> A >> B >> S;
        --A;
        --B;
        syn[j] = {A, B, S};
    }
    int S = N + K, T = N + K + 1;
    Dinic mf(N + K + 2);

    ll totalPos = 0;
    for (int i = 0; i < N; i++) {
        if (P[i] >= 0) {
            mf.add_edge(S, i, P[i]);
            totalPos += P[i];
        } else {
            mf.add_edge(i, T, -P[i]);
        }
    }
    for (auto &d : deps) {
        int u, v;
        tie(u, v) = d;
        mf.add_edge(v, u, INF);
    }
    for (int j = 0; j < K; j++) {
        int node = N + j;
        ll S_j = get<2>(syn[j]);
        mf.add_edge(S, node, S_j);
        totalPos += S_j;
        // 取るなら両都市を取る => node->A, node->B に無限容量
        int A = get<0>(syn[j]), B = get<1>(syn[j]);
        mf.add_edge(node, A, INF);
        mf.add_edge(node, B, INF);
    }
    ll mincut = mf.max_flow(S, T);
    ll answer = totalPos - mincut;
    cout << answer << "\n";
    return 0;
}