/// Preset de infoarena
#include <fstream>
#include <vector>
#include <queue>

using namespace std;

ifstream fin("algola.in");
ofstream fout("algola.out");

const int maxN = 5005, maxN2 = 55, sursa = 0, dest = 5001, inf = 0x3f3f3f3f;
int n, m, p[maxN], cap[maxN][maxN], flux[maxN][maxN], cap2[maxN2][maxN2], max_flux, ans;
bool used[maxN];
vector <int> G[maxN], G2[maxN2];
queue <int> q;

bool bfs()
{
    for(int i = sursa; i <= dest; i++)
        used[i] = 0;
    while(!q.empty())
        q.pop();
    q.push(0);
    used[0] = 1;
    while(!q.empty())
    {
        int nod = q.front();
        q.pop();
        for(int vecin : G[nod])
        {
            if(used[vecin])
                continue;
            if(cap[nod][vecin] > flux[nod][vecin])
            {
                p[vecin] = nod;
                used[vecin] = 1;
                q.push(vecin);
            }
        }
    }
    return used[dest];
}

void calc_flux()
{
    while(bfs())
    {
        int min_flux = inf;
        for(int x = dest; x != sursa; x = p[x])
            min_flux = min(min_flux, cap[p[x]][x] - flux[p[x]][x]);
        for(int x = dest; x != sursa; x = p[x])
        {
            flux[p[x]][x] += min_flux;
            flux[x][p[x]] -= min_flux;
        }
        max_flux -= min_flux;
    }
}

int main()
{
    fin >> n >> m;
    for(int i = 1; i <= n; i++)
    {
        int x;
        fin >> x;
        G[sursa].push_back(i);
        G[i].push_back(sursa);
        cap[0][i] = x;
        max_flux += x;
    }
    for(int i = 1; i <= m; i++)
    {
        int x, y, c;
        fin >> x >> y >> c;
        G2[x].push_back(y);
        G2[y].push_back(x);
        cap2[x][y] = c;
        cap2[y][x] = c;
    }
    G[1].push_back(dest);
    G[dest].push_back(1);
    cap[1][dest] = inf;
    calc_flux();
    while(max_flux)
    {
        ans++;
        G[ans * n + 1].push_back(dest);
        G[dest].push_back(ans * n + 1);
        cap[ans * n + 1][dest] = inf;
        for(int i = 1; i <= n; i++)
        {
            for(int nxt : G2[i])
            {
                int x = n * (ans - 1) + i, y = n * ans + nxt;
                G[x].push_back(y);
                G[y].push_back(x);
                cap[x][y] = cap2[i][nxt];
            }
            int x = n * (ans - 1) + i, y = n * ans + i;
            G[x].push_back(y);
            G[y].push_back(x);
            cap[x][y] = inf;
        }
        calc_flux();
    }
    fout << ans;
    return 0;
}