#include <bits/stdc++.h>
using namespace std;
struct pairhash {
 public:
  template <typename T, typename U>
  size_t operator()(const pair<T, U>& x) const {
    size_t seed = hash<T>()(x.first);
    return hash<U>()(x.second) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
  }
};
const long long inf = 1e9 + 9;
const long long mod = 1e9 + 7;
const double eps = 1e-8;
const double pi = acos(-1);
long long n, m;
long long x[100100];
struct edge {
  long long a, b;
  long long y;
};
vector<edge> es;
struct info {
  long long w_sum;
  long long num_e;
  long long y_max;
  long long parent;
};
class UnionFind {
 private:
  static const long long MAX = 100100;
  info par[MAX];
  long long r[MAX];

 public:
  UnionFind(long long n = MAX) {
    for (long long i = 0; i < n; i++) {
      info v;
      v.w_sum = x[i];
      v.num_e = 0;
      v.y_max = 0;
      v.parent = -1;
      par[i] = v;
      r[i] = 0;
    }
  }
  long long find(long long x) {
    if (par[x].parent < 0) {
      return x;
    } else {
      return par[x].parent = find(par[x].parent);
    }
  }
  void unite(long long x, long long y, long long yw) {
    x = find(x);
    y = find(y);
    if (x == y) {
      par[x].num_e++;
      par[x].y_max = max(par[x].y_max, yw);
      return;
    }
    if (r[x] < r[y]) {
      par[y].w_sum += par[x].w_sum;
      par[y].num_e += par[x].num_e + 1;
      par[y].y_max = max(max(par[y].y_max, par[x].y_max), yw);
      par[x].parent = y;
    } else {
      par[x].w_sum += par[y].w_sum;
      par[x].num_e += par[y].num_e + 1;
      par[x].y_max = max(max(par[x].y_max, par[y].y_max), yw);
      par[y].parent = x;
      if (r[x] == r[y]) r[x]++;
    }
  }
  bool same(long long x, long long y) { return find(x) == find(y); }
  bool valid(long long x) {
    long long v = find(x);
    return par[v].w_sum >= par[v].y_max;
  }
  long long num_e(long long x) { return par[find(x)].num_e; }
  info get(long long x) { return par[find(x)]; }
};
long long solve() {
  sort((es).begin(), (es).end(),
       [](const edge& e0, const edge& e1) { return e0.y < e1.y; });
  UnionFind uf(n);
  long long res = 0;
  long long temp = 0;
  for (long long i = 0; i < m; i++) {
    edge e = es[i];
    if (!uf.same(e.a, e.b)) {
      long long val_e = 0, inval_e = 0;
      if (uf.valid(e.a))
        val_e += uf.num_e(e.a);
      else
        inval_e += uf.num_e(e.a);
      if (uf.valid(e.b))
        val_e += uf.num_e(e.b);
      else
        inval_e += uf.num_e(e.b);
      uf.unite(e.a, e.b, e.y);
      if (uf.valid(e.a))
        temp += uf.num_e(e.a) - val_e;
      else
        temp -= val_e;
    } else {
      long long val_e = 0, inval_e = 0;
      if (uf.valid(e.a))
        val_e += uf.num_e(e.a);
      else
        inval_e += uf.num_e(e.a);
      uf.unite(e.a, e.b, e.y);
      if (uf.valid(e.a))
        temp += uf.num_e(e.a) - val_e;
      else
        temp -= val_e;
    }
    res = max(res, temp);
  }
  return m - res;
}
void input() {
  cin >> n >> m;
  for (long long i = 0; i < n; i++) cin >> x[i];
  for (long long i = 0; i < m; i++) {
    edge e;
    cin >> e.a >> e.b >> e.y;
    e.a--;
    e.b--;
    es.push_back(e);
  }
}
signed main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout << fixed << setprecision(15);
  input();
  cout << solve() << '\n';
}
