#include<cstdio>
#include<bitset>
#include<queue>
#include<vector>
#define N 5001
#define M 30000
#define D 1
#define S N
#define INF 30000000
using namespace std;

bitset<N+1> viz;

class mazi{
public:
    int nod,cap;
};

vector<int> vecin[N+1];
vector<mazi> muchii[51];

int c[N+1][N+1];
int f[N+1][N+1];

int n;

int R;
int tata[N+1];

int minim(int a,int b){
    return (a<b) ? a : b;
}

bool bfs(){
    viz.reset();

    queue<int> q;
    q.push(S);
    viz.set(S);

    while(!q.empty()){
        int nod=q.front();
        q.pop();

        if (nod==D) break ;

        //for(int i : vecin[nod]){
        for(int aux=0;aux<vecin[nod].size();aux++){
            int i=vecin[nod][aux];
            if (viz[i]==false &&c[nod][i]-f[nod][i]>0){
                viz.set(i);
                q.push(i);
                tata[i]=nod;
            }
        }
    }

    return viz[D];
}

void solve(){
    while(bfs()){
        int i;
        for(i=2;i<N;i++){
            if (c[i][D]-f[i][D]>0 &&viz[i]==true){
                tata[D]=i;

                int p=D;
                int min=c[tata[p]][p]-f[tata[p]][p];
                p=i;
                while(p!=S){
                    min=minim(min,c[tata[p]][p]-f[tata[p]][p]);
                    p=tata[p];
                }

                R+=min;

                p=D;
                while(p!=S){
                    f[tata[p]][p]+=min;
                    f[p][tata[p]]-=min;
                    p=tata[p];
                }
            }
        }
    }
}

mazi pair_(int a,int b){
    mazi r;
    r.nod=a;
    r.cap=b;
    return r;
}

int main(){
    freopen ("algola.in","r",stdin);
    freopen ("algola.out","w",stdout);
    int m,i;
    int nrmem=0;
    int x,y,l;

    scanf ("%d%d",&n,&m);
    scanf ("%d",&i);

    for(i=2;i<=n;i++){
        scanf ("%d",&c[S][i]);
        if (c[S][i]!=0){
            vecin[S].push_back(i);
            vecin[i].push_back(S);
        }
        nrmem+=c[S][i];
    }

    for(i=1;i<=m;i++){
        scanf ("%d%d%d",&x,&y,&l);

        if (y!=D) muchii[x].push_back(pair_(y,l));
        if (x!=D) muchii[y].push_back(pair_(x,l));
    }

    solve();
    int T=0;
    while(R<nrmem){
        T++;

        //for(mazi nod : muchii[D]){
        for(i=0;i<muchii[D].size();i++){
            mazi nod=muchii[D][i];
            vecin[(T-1)*n+nod.nod].push_back(D);
            vecin[D].push_back((T-1)*n+nod.nod);
            c[(T-1)*n+nod.nod][D]=nod.cap;
        }

        for(i=2;i<=n;i++){
            //for(mazi j : muchii[i]){
            for(l=0;l<muchii[i].size();l++){
                mazi j=muchii[i][l];
                vecin[T*n+j.nod].push_back((T-1)*n+i);
                vecin[(T-1)*n+i].push_back(T*n+j.nod);
                c[(T-1)*n+i][T*n+j.nod]=j.cap;
                c[T*n+j.nod][(T-1)*n+i]=j.cap;
            }
            vecin[(T-1)*n+i].push_back(T*n+i);
            vecin[T*n+i].push_back((T-1)*n+i);
            c[(T-1)*n+i][T*n+i]=INF;
        }

        solve();
    }

    printf ("%d",T);
    return 0;
}