#include <bits/stdc++.h>

using namespace std;

const int MAXN = 50;
const int MAXNODES = MAXN * 100 + 10;
const char INF = 100;

vector <int> g[MAXNODES];
int seen[MAXNODES], father[MAXNODES];
char cap[MAXNODES][MAXNODES], flow[MAXNODES][MAXNODES];
queue <int> q;

int bfs(int n) {
  int node;
  memset(seen, 0, sizeof(seen));
  seen[0] = 1;
  q.push(0);
  while (q.empty() == 0) {
    node = q.front();
    if (node != n)
      for (auto it : g[node])
        if (seen[it] == 0 && flow[node][it] < cap[node][it]) {
          seen[it] = 1;
          father[it] = node;
          q.push(it);
        }
    q.pop();
  }
  return seen[n];
}

inline int minim(int A, int B) {
  if (A < B)
    return A;
  return B;
}

int maxfl;

int maxflow(int n) {
  int node;
  char fl;
  while (bfs(n))
    for (auto it : g[n])
      if (seen[it] && flow[it][n] < cap[it][n]) {
        father[n] = it; fl = INF;
        for (node = n; node > 0; node = father[node])
          fl = minim(fl, cap[father[node]][node] - flow[father[node]][node]);
        for (node = n; node > 0; node = father[node]) {
          flow[father[node]][node] += fl;
          flow[node][father[node]] -= fl;
        }
        maxfl += fl;
      }
  return maxfl;
}

inline void create_edge(int node1, int node2, int capacity) {
  g[node1].push_back(node2);
  g[node2].push_back(node1);
  cap[node1][node2] = capacity;
}

struct Stuff {
  int node;
  char capacity;
};

vector <Stuff> init_g[MAXN + 1];

int main()
{
    int n, m, pop, nr, s, d, time, a, b;
    ifstream fin("algola.in");
    fin >> n >> m;
    s = pop = 0; d = MAXNODES - 1;
    for (int i = 1; i <= n; ++i) {
      fin >> nr;
      pop += nr;
      create_edge(s, i, nr);
    }
    for (int i = 0; i < m; ++i) {
      fin >> a >> b >> nr;
      init_g[a].push_back({b, nr});
      init_g[b].push_back({a, nr});
    }
    fin.close();
    create_edge(1, d, INF);
    time = 0;
    while (maxflow(d) < pop) {
      ++time;
      for (int i = 1; i <= n; ++i) {
        create_edge(n * (time - 1) + i, n * time + i, INF);
        for (auto it : init_g[i])
          create_edge(n * (time - 1) + i, n * time + it.node, it.capacity);
      }
      create_edge(n * time + 1, d, INF);
    }
    ofstream fout("algola.out");
    fout << time << '\n';
    fout.close();
    return 0;
}