#include <fstream>
#include <vector>
#include <cstring>
#include <queue>
#include <iostream>
 
#define mp make_pair
#define forEach(G) for( typeof(G.begin()) it = G.begin() ; it != G.end() ; ++ it)
#define pb push_back
 
using namespace std;
 
const int maxn = 60,maxt = maxn*2;
const int _source = 0 , _sink = maxn-5;
const int maxest = maxn*maxt;
const int INF = 100;
 
ifstream in("algola.in");
ofstream out("algola.out");
 
int each[maxn];
int maximum;
char C[maxest][maxest];
char F[maxest][maxest];
int TT[maxest],Time;
int n,m,fnd;
vector< int > G[maxest];
vector< pair<int,int> > original[maxn];
queue<int> Q;
 
bool bfs(){
    while(!Q.empty())Q.pop();
    memset(TT,0,sizeof(TT));
    Q.push(_source);
    int nod;
    while(!Q.empty()){
        nod = Q.front();Q.pop();
 
        if(nod == _sink)continue;
        forEach(G[nod]){
 
            if(TT[*it] || F[nod][*it] == C[nod][*it])continue;
            TT[*it] = nod;
            Q.push(*it);
        }
    }
    return TT[_sink];
}
 
void flux(){
    int nod,fmin;
 
    while(bfs()){
 
        forEach(G[_sink]){
 
            if(!TT[*it])continue;
            fmin = INF;
 
            for(nod = *it; nod != _source ; nod = TT[nod])
                fmin = min(fmin,C[TT[nod]][nod] - F[TT[nod]][nod]);
 
            if(fmin == 0)continue;
            fnd += fmin;
            for(nod = *it; nod != _source; nod = TT[nod]){
                F[TT[nod]][nod] += fmin;
                F[nod][TT[nod]] -= fmin;
            }
        }
    }
}
 
void extra(const int T){
    const int off1 = T*maxn,
        off2 = (T+1)*maxn;
    int i;
    for(i = 1 ; i <= n ; ++ i){
        forEach(original[i]){
 
            C[off1+i][off2+it->first] = it->second;
 
            G[off1+i].pb(off2+it->first);
 
        }
    }
    C[off2+1][_sink] = INF;
    G[off2+1].pb(_sink);
    G[_sink].pb(off2+1);
}
 
int main()
{
    in >> n >> m;int i,x,y,c,p;
    for(i=1;i<=n;++i){
        in >> p;
        each[i] = p;
        original[i].pb(mp(i,INF));
        maximum += each[i];
    }
    while(m--){
        in >> x >> y >> c;
 
        original[x].pb(mp(y,c));
        original[y].pb(mp(x,c));
 
    }
 
    for(i=2;i<=n;++i){
        C[_source][i] = each[i];
        G[_source].pb(i);
        G[i].pb(_source);
    }
    Time = 0;
 
    while(fnd != maximum && Time < maxt){
        extra(Time++);
        flux();
    }
    out << Time << "\n";
    return 0;
}