#include <bits/stdc++.h>
using namespace std;
namespace {
using Integer = long long;
template <class T, class S>
istream& operator>>(istream& is, pair<T, S>& p) {
  return is >> p.first >> p.second;
}
template <class T>
istream& operator>>(istream& is, vector<T>& vec) {
  for (T& val : vec) is >> val;
  return is;
}
template <class T>
istream& operator,(istream& is, T& val) {
  return is >> val;
}
template <class T, class S>
ostream& operator<<(ostream& os, const pair<T, S>& p) {
  return os << p.first << " " << p.second;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& vec) {
  for (size_t i = 0; i < vec.size(); i++)
    os << vec[i] << (i == vec.size() - 1 ? "" : " ");
  return os;
}
template <class T>
ostream& operator,(ostream& os, const T& val) {
  return os << " " << val;
}
template <class H>
void print(const H& head) {
  cout << head;
}
template <class H, class... T>
void print(const H& head, const T&... tail) {
  cout << head << " ";
  print(tail...);
}
template <class... T>
void println(const T&... values) {
  print(values...);
  cout << endl;
}
template <class H>
void eprint(const H& head) {
  cerr << head;
}
template <class H, class... T>
void eprint(const H& head, const T&... tail) {
  cerr << head << " ";
  eprint(tail...);
}
template <class... T>
void eprintln(const T&... values) {
  eprint(values...);
  cerr << endl;
}
class range {
  Integer start_, end_, step_;

 public:
  struct range_iterator {
    Integer val, step_;
    range_iterator(Integer v, Integer step) : val(v), step_(step) {}
    Integer operator*() { return val; }
    void operator++() { val += step_; }
    bool operator!=(range_iterator& x) {
      return step_ > 0 ? val < x.val : val > x.val;
    }
  };
  range(Integer len) : start_(0), end_(len), step_(1) {}
  range(Integer start, Integer end) : start_(start), end_(end), step_(1) {}
  range(Integer start, Integer end, Integer step)
      : start_(start), end_(end), step_(step) {}
  range_iterator begin() { return range_iterator(start_, step_); }
  range_iterator end() { return range_iterator(end_, step_); }
};
inline string operator"" _s(const char* str, size_t size) {
  return move(string(str));
}
constexpr Integer my_pow(Integer x, Integer k, Integer z = 1) {
  return k == 0    ? z
         : k == 1  ? z * x
         : (k & 1) ? my_pow(x * x, k >> 1, z * x)
                   : my_pow(x * x, k >> 1, z);
}
constexpr Integer my_pow_mod(Integer x, Integer k, Integer M, Integer z = 1) {
  return k == 0    ? z % M
         : k == 1  ? z * x % M
         : (k & 1) ? my_pow_mod(x * x % M, k >> 1, M, z * x % M)
                   : my_pow_mod(x * x % M, k >> 1, M, z);
}
constexpr unsigned long long operator"" _ten(unsigned long long value) {
  return my_pow(10, value);
}
inline int k_bit(Integer x, int k) { return (x >> k) & 1; }
mt19937 mt(chrono::duration_cast<chrono::nanoseconds>(
               chrono::steady_clock::now().time_since_epoch())
               .count());
template <class T>
string join(const vector<T>& v, const string& sep) {
  stringstream ss;
  for (size_t i = 0; i < v.size(); i++) {
    if (i > 0) ss << sep;
    ss << v[i];
  }
  return ss.str();
}
inline string operator*(string s, int k) {
  string ret;
  while (k) {
    if (k & 1) ret += s;
    s += s;
    k >>= 1;
  }
  return ret;
}
}  // namespace
constexpr long long mod = 9_ten + 7;
class UnionFindTree {
  struct base_node {
    int parent;
    int rank;
    int size;
  };
  vector<base_node> node;

 public:
  UnionFindTree(int n) {
    node.resize(n);
    for (int i = 0; i < n; i++) {
      node[i].parent = i;
      node[i].rank = 0;
      node[i].size = 1;
    }
  }
  int find(int x) {
    if (node[x].parent == x)
      return x;
    else {
      return node[x].parent = find(node[x].parent);
    }
  }
  bool same(int x, int y) { return find(x) == find(y); }
  int size(int at) { return node[find(at)].size; }
  void unite(int x, int y) {
    x = find(node[x].parent);
    y = find(node[y].parent);
    if (x == y) return;
    if (node[x].rank < node[y].rank) {
      node[x].parent = y;
      node[y].size += node[x].size;
    } else if (node[x].rank > node[y].rank) {
      node[y].parent = x;
      node[x].size += node[y].size;
    } else {
      node[x].rank++;
      unite(x, y);
    }
  }
};
int main() {
  int n, m;
  cin >> n, m;
  vector<long long> x(n);
  cin >> x;
  vector<long long> a(m), b(m), y(m);
  for (int i = 0; i < m; i++) {
    cin >> a[i], b[i], y[i];
    a[i]--;
    b[i]--;
  }
  vector<pair<long long, int>> e(m);
  for (int i = 0; i < m; i++) {
    e[i] = {y[i] - (x[a[i]] + x[b[i]]), i};
  }
  sort(e.rbegin(), e.rend());
  auto check = [&](int e0) {
    UnionFindTree uft(n);
    for (int i = e0; i < m; i++) {
      uft.unite(a[e[i].second], b[e[i].second]);
    }
    vector<long long> w(n);
    for (int i = 0; i < n; i++) {
      w[uft.find(i)] += x[i];
    }
    for (int i = e0; i < m; i++) {
      int p = uft.find(a[e[i].second]);
      if (w[p] < y[e[i].second]) return false;
    }
    return true;
  };
  long long lb = -1;
  long long ub = m;
  while (ub - lb > 1) {
    long long mid = (lb + ub) / 2;
    bool ok = check(mid);
    (ok ? ub : lb) = mid;
  }
  println(ub);
  return 0;
}
