#include <bits/stdc++.h>

using namespace std;
using ll = long long;

template<typename T>
struct Fenwick {
    int n;
    vector<T> a;

    Fenwick() = default;

    explicit Fenwick(int n) : n(n), a(n + 1) {}

    void modify(int x, T v) {
        for (int i = x + 1; i <= n; i += i & -i) {
            a[i] += v;
        }
    }

    void modify(int l, int r, T v) {
        if (l >= r) return;
        modify(l, v), modify(r, -v);
    }

    T sum(int x) {
        T ans = 0;
        for (int i = x + 1; i > 0; i -= i & -i) {
            ans += a[i];
        }
        return ans;
    }

    T rangeSum(int l, int r) { //[l, r)
        if (l >= r) return 0;
        return sum(r - 1) - sum(l - 1);
    }

    int kth(T k) {
        int x = 0;
        for (int i = 1 << __lg(n); i; i >>= 1) {
            if (x + i <= n && k > a[x + i]) {
                x += i;
                k -= a[x];
            }
        }
        return x;
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;

    vector<int> a(n), L(n), R(n);
    vector<pair<int, int>> stk;

    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

    int m;
    cin >> m;

    vector<int> x(m), y(m), c(m);
    vector<vector<int>> adj(n);

    for (int i = 0; i < m; ++i) {
        cin >> x[i] >> y[i] >> c[i];
        adj[--x[i]].push_back(i);
    }

    stk = {{1e9 + 7, -1}};
    for (int i = 0; i < n; ++i) {
        while (!stk.empty() && stk.back().first <= a[i]) {
            stk.pop_back();
        }
        stk.emplace_back(a[i], i);
        for (int j : adj[i]) {
            L[j] = lower_bound(stk.rbegin(), stk.rend(), pair{y[j], -1})->second + 1;
        }
    }

    stk = {{1e9 + 7, n}};
    for (int i = n - 1; i >= 0; --i) {
        while (!stk.empty() && stk.back().first <= a[i]) {
            stk.pop_back();
        }
        stk.emplace_back(a[i], i);
        for (int j : adj[i]) {
            R[j] = lower_bound(stk.rbegin(), stk.rend(), pair{y[j], -1})->second - 1;
        }
    }

    vector<int> ord(m);
    iota(ord.begin(), ord.end(), 0);
    sort(ord.begin(), ord.end(), [&](int i, int j) {
        return array{R[i] - L[i], L[i], i} < array{R[j] - L[j], L[j], j};
    });

    Fenwick<ll> fn(n);

    ll ans = accumulate(c.begin(), c.end(), 0LL);

    for (int i : ord) {
        ll diff = c[i] - fn.sum(x[i]);
        if (diff > 0) {
            ans -= diff;
            fn.modify(L[i], R[i] + 1, diff);
        }
    }

    cout << ans << '\n';

    return 0;
}