#include <bits/stdc++.h>
using namespace std;
class FordFurkerson {
  vector<vector<array<int64_t, 3>>> E;
  vector<bool> visited;
  const int64_t INF = 1e18;

 public:
  FordFurkerson(int64_t n) : E(n), visited(n) {}
  void add_edge(int64_t from, int64_t to, int64_t cap) {
    E[from].push_back({to, cap, (int64_t)E[to].size()});
    E[to].push_back({from, 0, (int64_t)E[from].size() - 1});
  }
  int64_t dfs(int64_t v, int64_t t, int64_t flow) {
    if (v == t) return flow;
    if (flow == 0) return 0;
    if (visited[v]) return 0;
    visited[v] = true;
    for (auto &[to, cap, rev] : E[v]) {
      auto res = dfs(to, t, min(cap, flow));
      if (res > 0) {
        cap -= res;
        E[to][rev][1] += res;
        return res;
      }
    }
    return 0;
  }
  int64_t calc_flow(int64_t s, int64_t t) {
    int64_t flow = 0;
    while (true) {
      fill(visited.begin(), visited.end(), false);
      auto res = dfs(s, t, INF);
      if (res == 0) return flow;
      flow += res;
    }
  }
};
int main() {
  int n, m;
  cin >> n >> m;
  FordFurkerson flow(n + m + 2);
  const constexpr int64_t INF = 1e17;
  const int s = n + m, t = s + 1;
  int64_t ans = 0;
  for (int i = 0; i < n; i++) {
    int a;
    cin >> a;
    flow.add_edge(i, t, a);
  }
  for (int i = 0; i < m; i++) {
    int x, y, w;
    cin >> x >> y >> w;
    x--;
    y--;
    flow.add_edge(s, n + i, w);
    flow.add_edge(n + i, x, INF);
    flow.add_edge(n + i, y, INF);
    ans += w;
  }
  cout << ans - flow.calc_flow(s, t) << endl;
}
