#include<cstdio>
#include<bitset>
#include<queue>
#include<vector>
#define N 5001
#define M 30000
#define D N
#define S 0
#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=0;i<vecin[nod].size();i++){
            if (viz[vecin[nod][i]]==false &&c[nod][vecin[nod][i]]-f[nod][vecin[nod][i]]>0){
                viz.set(vecin[nod][i]);
                tata[vecin[nod][i]]=nod;
                q.push(vecin[nod][i]);
            }
        }
    }

    return viz[D];
}

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

                int p=D;
                int min=c[tata[p]][p]-f[tata[p]][p];
                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);

        muchii[x].push_back(pair_(y,l));
        muchii[y].push_back(pair_(x,l));
    }

    vecin[1].push_back(D);
    vecin[D].push_back(1);
    c[1][D]=INF;

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

        for(i=1;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;
            }
            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;
        }

        vecin[T*n+1].push_back(D);
        vecin[D].push_back(T*n+1);
        c[T*n+1][D]=INF;

        solve();
    }

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