#include <bits/stdc++.h>

template<typename weight_type = int>
class union_find {
    static_assert(
        std::is_arithmetic<weight_type>::value,
        "Invalid weight type");
private:
    std::vector<int> uni;
    
    std::vector<weight_type> weights;
    int size_;
    const void check(const int n) const {
        if (this->group_size() < 0) {
            assert(false);
        }
        if (!(0 <= n && n < this->all_size())) {
            assert(false);
        }
    }
public:
    std::vector<int> edge_count_;
    union_find() : uni(0), edge_count_(0), weights(0), size_(-1) {}
    union_find(const int n)
        : uni(n, -1), edge_count_(n), weights(n), size_(n) {
        this->check(n - 1);
    }
    union_find(const std::vector<weight_type> &_weights)
        : uni(_weights.size(), -1), edge_count_(_weights.size()),
        weights(_weights), size_(_weights.size()) {
        this->check((int)_weights.size() - 1);
    }
    bool same(const int a, const int b) {
        this->check(a);
        this->check(b);
        return this->find(a) == this->find(b);
    }
    int find(const int a) {
        this->check(a);
        return this->uni[a] < 0 ?
                a :
            this->uni[a] = this->find(this->uni[a]);
    }
    bool unite(int a, int b) {
        a = this->find(a);
        b = this->find(b);
        this->edge_count_[a]++;
        if (a == b) {
            return false;
        }
        this->size_--;
        if (this->uni[a] > this->uni[b]) {
            std::swap(a, b);
        }
        this->uni[a] += this->uni[b];
        this->weights[a] += this->weights[b];
        this->edge_count_[a] += this->edge_count_[b];
        this->uni[b] = a;
        return true;
    }
    const int group_size() const {
        return this->size_;
    }
    const int all_size() const {
        return this->uni.size();
    }
    const int size(const int a) {
        this->check(a);
        return -this->uni[this->find(a)];
    }
    const int edge_count(const int a) {
        this->check(a);
        return this->edge_count_[this->find(a)];
    }
    const int weight(const int a) {
        this->check(a);
        return this->weights[this->find(a)];
    }
};

using namespace std;

int main() {
  int N, M;
  cin >> N >> M;
  vector<long long> X(N);
  for_each(begin(X), end(X), [](auto &e){cin >> e;});
  union_find<long long> uf(X);
  vector<tuple<long long, int, int>> edges;
  for (int i = 0; i < M; i++) {
    int a, b;
    long long y;
    cin >> a >> b >> y;
    a--;
    b--;
    edges.emplace_back(y, a, b);
  }
  sort(begin(edges), end(edges));
  int live = 0;
  for (auto e : edges) {
    int a, b;
    long long w;
    tie(w, a, b) = e;
    uf.unite(a, b);
    const int par = uf.find(a);
    if (uf.weight(par) >= w) {
      live += uf.edge_count_[par];
      uf.edge_count_[par] = 0;
    }
  }
  cout << M - live << endl;
}