#include <bits/stdc++.h>

#define ll long long
#define ld long double
//#define endl '\n'
#define st first
#define nd second
#define pb push_back
#define sz(x) (int)(x).size()
#define all(x) (x).begin(), (x).end()
#define FOR(i,l,r) for(int i=(l);i<=(r);i++)
#define ROF(i,r,l) for(int i=(r);i>=(l);i--)
using namespace std;
int inf=1000000007;
ll infl=1000000000000000007;
int mod=1000000007;
int mod1=998244353;

const int N=200007,pot=1<<18;

struct T
{
    ll seg[2*pot+7];
    T()
    {
        memset(seg,0,sizeof seg);
    }
    void add(int v,int a,int b,int l,int r,int x)
    {
        if(a<=l&&b>=r)
        {
            seg[v]+=x;
            return ;
        }
        if(r<a||l>b) return;
        add(2*v,a,b,l,(l+r)/2,x);
        add(2*v+1,a,b,(l+r)/2+1,r,x);
    }
    ll que(int v)
    {
        ll res=0;
        v+=pot-1;
        while(v>0)
        {
            res+=seg[v];
            v/=2;
        }
        return res;
    }
};

int a[N],id[N],ord[N];

ll DPl[N],DPr[N];

int L[N],R[N];
int lx[N],rx[N];
vector<int>G[N],G1[N];
int pre[N],post[N],cc;
int pre1[N],post1[N];

void dfs(int v)
{
    pre[v]=++cc;
    for(auto u:G[v]) dfs(u);
    post[v]=cc;
}
void dfs1(int v)
{
    pre1[v]=++cc;
    for(auto u:G1[v]) dfs1(u);
    post1[v]=cc;
}

vector<pair<int,ll>>V[N];
pair<int,int>seg[2*pot+7];

void del(int v)
{
    V[v].pop_back();
    seg[v+pot-1]={V[v].back().st,v};
    v+=pot-1;
    while(v>1)
    {
        v/=2;
        seg[v]=min(seg[2*v],seg[2*v+1]);
    }
}

pair<int,int>que(int v,int a,int b,int l,int r)
{
    if(a<=l&&b>=r) return seg[v];
    if(r<a||l>b) return {inf,0};
    return min(que(2*v,a,b,l,(l+r)/2),que(2*v+1,a,b,(l+r)/2+1,r));
}

signed main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int n,m;
    cin>>n;
    vector<pair<int,int>>VV;
    a[0]=inf-1;
    a[n+1]=inf-1;
    id[n+1]=n+1;
    ord[n+1]=n+1;
    FOR(i,1,n)
    {
        cin>>a[i];
        VV.pb({a[i],i});
    }
    sort(all(VV));
    FOR(i,1,n)
    {
        id[VV[i-1].nd]=i;
        ord[i]=VV[i-1].nd;
    }
    deque<pair<int,int>>Q;
    Q.pb({inf,0});
    FOR(i,1,n+1)
    {
        while(Q.back().st<id[i])
        {
            R[Q.back().nd]=i;
            G1[i].pb(Q.back().nd);
            lx[i]=Q.back().nd;
            Q.pop_back();
        }
        L[i]=Q.back().nd;
        G[Q.back().nd].pb(i);
        rx[Q.back().nd]=i;
        Q.pb({id[i],i});
    }
    dfs(0);
    cc=0;
    dfs1(n+1);
    cin>>m;
    ll sum=0;
    FOR(i,1,m)
    {
        int x,y,c;
        cin>>x>>y>>c;
        V[x].pb({y,c});
        sum+=(ll)c;
    }
    FOR(i,1,n)
    {
        V[i].pb({inf,0});
        sort(all(V[i]),greater<pair<int,int>>());
        seg[i+pot-1]={V[i].back().st,i};
    }
    ROF(i,pot-1,1) seg[i]=min(seg[2*i],seg[2*i+1]);
    T S,S1;
    FOR(k,1,n+1)
    {
        int i=ord[k];
        //liczymy DPl
        DPl[i]=DPl[lx[i]]+DPr[lx[i]];
        while(true)
        {
            pair<int,int>p=que(1,L[i]+1,i-1,1,pot);
            if(p.st>a[i]) break;
            ll Ls=S.que(pre[p.nd])-S.que(pre[L[i]]);
            ll Rs=S1.que(pre1[p.nd])-S1.que(pre1[i]);
            DPl[i]=max(DPl[i],V[p.nd].back().nd+Ls+Rs);
            del(p.nd);
        }
        //liczymy DPr
        if(i==n+1) break;
        DPr[i]=DPl[rx[i]]+DPr[rx[i]];
        while(true)
        {
            pair<int,int>p=que(1,i+1,R[i]-1,1,pot);
            if(p.st>a[i]) break;
            ll Ls=S.que(pre[p.nd])-S.que(pre[i]);
            ll Rs=S1.que(pre1[p.nd])-S1.que(pre1[R[i]]);
            DPr[i]=max(DPr[i],V[p.nd].back().nd+Ls+Rs);
            del(p.nd);
        }
        S.add(1,pre[i],post[i],1,pot,DPl[i]);
        S1.add(1,pre1[i],post1[i],1,pot,DPr[i]);
    }
    cout<<sum-DPl[n+1]<<endl;

    return 0;
}