#include <fstream>
#include <vector>

using namespace std;

#define foreach(V) for(typeof (V).begin() it = (V).begin(); it != (V).end(); ++it)

const int MAX_N = 55;
const int MAX_T = 5505;
const int INF = 0x3f3f3f3f;
const int t = 100;

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

int S, D, N, M, A[MAX_N], K, T[MAX_T];
int F[MAX_T][MAX_T], C[MAX_T][MAX_T], flow;

char viz[MAX_T];

vector <pair<int, int> > L[MAX_N];
vector <int> G[MAX_T];

void citire()
{
	fin >> N >> M;

	for(int i = 1; i <= N; ++i)
	{
		fin >> A[i];
		K += A[i];
	}

	for(int i = 1; i <= M; ++i)
	{
		int x, y, c;
		fin >> x >> y >> c;

		L[x].push_back(make_pair(y, c));
		L[y].push_back(make_pair(x, c));
	}
}

bool bfs()
{
	int Q[MAX_T];
	memset(viz, 0, sizeof viz);

	Q[0] = 1; Q[1] = 0;
	viz[0] = 1;

	for(int i = 1; i <= Q[0]; ++i)
	{
		int nod = Q[i];

		if(nod == D) continue;

		foreach(G[nod])
		{
			int act = *it;

			if(viz[act] || F[nod][act] == C[nod][act]) continue;

			viz[act] = 1;
			Q[++Q[0]] = act;
			T[act] = nod;
		}
	}

	return viz[D];
}

bool check(int P)
{
	for(int i = 1; i <= N; ++i)
		{
			foreach(L[i])
			{
				int j = it -> first;
				int c = it -> second;
				C[t*i + P][t*j + P+1] = c;

				G[t*i + P].push_back(t*j + P+1);
				G[t*j + P+1].push_back(t*i + P);	
			}

			C[t*i + P][t*i + P+1] = INF;
			G[t*i + P].push_back(t*i + P+1);
			G[t*i + P+1].push_back(t*i + P);
		}

	D = P + t;

	while(bfs())
		for(size_t i = 0; i < G[D].size(); ++i)
		{
			int nod = G[D][i];

			if(F[nod][D] == C[nod][D] || viz[nod] == 0) continue;

			int fmin = INF;
			for(int i = D; i; i = T[i])
				fmin = min(fmin, C[T[i]][i] - F[T[i]][i]);

			for(int i = D; i; i = T[i])
				F[T[i]][i] += fmin,
				F[i][T[i]] -= fmin;

			flow += fmin;
		}

	return (flow >= K);
}

int main()
{
	citire();

	for(int i = 1; i <= N; ++i)
	if(A[i])
	{
		C[0][t*i] = A[i];
		G[0].push_back(t*i);
		G[t*i].push_back(0);
	}

	int l = 0;
	for(; l <= 100; ++l)
		if(check(l))
			break;

	fout << l;
}