#include <algorithm>
#include <vector>
#include <queue>
using namespace std;

#define pb push_back

#define INF 0x3f3f3f3f
#define TMAX 105
#define MAX 305
#define DIM 55

int c[DIM*TMAX][DIM*TMAX],f[DIM*TMAX][DIM*TMAX];
struct muchie {int x,y,c;} muc[MAX];
int N,M,T,cnt,S,D,total_flow;
vector <int> g[DIM*TMAX];
int t[DIM*TMAX];
queue <int> q;

void read ()
{
    int i;

    scanf ("%d%d",&N,&M);

    S=0; D=N*TMAX+1;
    for (i=1; i<=N; ++i)
    {
        scanf ("%d",&c[S][i]);
        cnt+=c[S][i];
        g[S].pb (i);
        g[i].pb (S);
    }

    for (i=1; i<=M; ++i)
        scanf ("%d%d%d",&muc[i].x,&muc[i].y,&muc[i].c);
}

int bf ()
{
    vector <int> :: iterator it;
    int nod;

    memset (t,-1,sizeof (t));
    t[S]=0;
    for (q.push (S); !q.empty (); q.pop ())
    {
        nod=q.front ();
        for (it=g[nod].begin (); it!=g[nod].end (); ++it)
            if (t[*it]==-1 && c[nod][*it]!=f[nod][*it])
            {
                t[*it]=nod;
                q.push (*it);
            }
    }
    return t[D]!=-1;
}

void solve ()
{
    vector <int> :: iterator it;
    int i,min_cur;

    c[1][D]=INF;
    g[1].pb (D);
    g[D].pb (1);

    while (total_flow<cnt)
    {
        while (bf ())
        {
            for (it=g[D].begin (); it!=g[D].end (); ++it)
                if (t[*it]!=-1 && c[*it][D]!=f[*it][D])
                {
                    min_cur=c[*it][D]-f[*it][D];
                    for (i=*it; i!=S; i=t[i])
                        min_cur=min (min_cur,c[t[i]][i]-f[t[i]][i]);

                    f[*it][D]+=min_cur;
                    f[D][*it]-=min_cur;
                    for (i=*it; i!=S; i=t[i])
                    {
                        f[t[i]][i]+=min_cur;
                        f[i][t[i]]-=min_cur;
                    }

                    total_flow+=min_cur;
                }
        }

        for (i=N*T+1; i<=N*T+N; ++i)
        {
            c[i][i+N]=INF;
            g[i].pb (i+N);
            g[i+N].pb (i);
        }

        for (i=1; i<=M; ++i)
        {
            c[muc[i].x+N*T][muc[i].y+N*T+N]=muc[i].c;
            g[muc[i].x+N*T].pb (muc[i].y+N*T+N);
            g[muc[i].y+N*T+N].pb (muc[i].x+N*T);

            c[muc[i].y+N*T][muc[i].x+N*T+N]=muc[i].c;
            g[muc[i].y+N*T].pb (muc[i].x+N*T+N);
            g[muc[i].x+N*T+N].pb (muc[i].y+N*T);
        }

        ++T;
        c[N*T+1][D]=INF;
        g[N*T+1].pb (D);
        g[D].pb (N*T+1);
    }

    printf ("%d",T-1);
}

int main ()
{
    freopen ("algola.in","r",stdin);
    freopen ("algola.out","w",stdout);

    read ();
    solve ();

    return 0;
}