#include <bits/stdc++.h>

using namespace std;

#define INFILE "algola.in"
#define OUTFILE "algola.out"

const int N_MAX = 50;
const int M_MAX = 300;
const int NODES_MAX = 5e3;
const int INF = 1e9;

struct Node {

    int node, capacity;

    Node() {}
    Node(int _node, int _capacity) : node(_node), capacity(_capacity) {}

};

int nodes, edges;
int destinationNode;
int parent[NODES_MAX + 5];
vector<int> adj[NODES_MAX + 5];
vector<Node> adjInitial[N_MAX + 5];
short flow[NODES_MAX + 5][NODES_MAX + 5];
short capacity[NODES_MAX + 5][NODES_MAX + 5];

void makeEdge(int node1, int node2, int capa){
    adj[node1].push_back(node2);
    adj[node2].push_back(node1);
    capacity[node1][node2] = capa;
}

bool dfs(){

    memset(parent, -1, sizeof parent);    

    queue<int> q; q.push(0);
    parent[0] = 0;
    
    while(!q.empty()){

        int node = q.front(); q.pop();

        for(auto &to : adj[node]){
            if(parent[to] == -1 && capacity[node][to] > flow[node][to]){
                parent[to] = node;
                if(node != destinationNode) q.push(to);
            }
        }

    }

    return parent[destinationNode] != -1;

}

void solve(){

    int persons = 0, maxFlow = 0, time;

    cin >> nodes >> edges;
    for(int i = 1; i <= nodes; ++i){
        int aux; cin >> aux;
        makeEdge(0, i, aux);
        persons += aux;
    }

    for(int i = 0; i < edges; ++i){
        int node1, node2, capa; cin >> node1 >> node2 >> capa;
        adjInitial[node1].push_back(Node(node2, capa));
        adjInitial[node2].push_back(Node(node1, capa));
    }

    for(time = 1; maxFlow < persons; ++time){

        destinationNode = nodes * time + 1;
        for(int i = 1; i <= nodes; ++i){
            makeEdge(nodes * (time - 1) + i, nodes * time + i, INF);
            for(auto &to : adjInitial[i]){
                makeEdge(nodes * (time - 1) + i, nodes * time + to.node, to.capacity);
            }
        }

        while(dfs()){

            int auxFlow = INF;

            for(int i = destinationNode; i != 0; i = parent[i]){
                auxFlow = min(auxFlow, capacity[parent[i]][i] - flow[parent[i]][i]);
            }
            for(int i = destinationNode; i != 0; i = parent[i]){
                flow[parent[i]][i] += auxFlow;
                flow[i][parent[i]] -= auxFlow;
            }

            maxFlow += auxFlow;

        }

    }

    cout << time - 1 << '\n';

}

int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    freopen(INFILE, "r", stdin);
    freopen(OUTFILE, "w", stdout);
    solve();
    return 0;
}