#include <cmath>
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <list>
#include <time.h>
#include <math.h>
#include <random>
#include <deque>
#include <queue>
#include <cassert>
#include <unordered_map>
#include <unordered_set>
#include <iomanip>
#include <bitset>
#include <sstream>
#include <chrono>
#include <cstring>

using namespace std;

typedef long long ll;

#ifdef iq
  mt19937 rnd(228);
#else
  mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
#endif

const int N = 500;

int x[N][N], y[N][N];
int f[N];

int n, m;

int vis[N];
int p[N];

int tt = 0;

auto ch = [] (int i, int j, int delta) {
  x[i][j] += delta, x[j][i] += delta;
  y[i][j] -= delta, y[j][i] -= delta;
};

int ptr[N];

int s = -1;

int dfs(int v, int cur){
  vis[v] = tt;
  for (int i = 0; i < n; i++) {
    if ((x[v][i] >= cur && f[i] >= cur && i != s) || (x[v][i] >= cur && i == s && f[i] >= 2 * cur)) {
      f[i] -= cur;
      ch(v, i, -cur);
      return cur;
    }
  }
  for (int i = 0; i < n; i++) {
    if (x[v][i] >= cur) {
      for (int j = 0; j < n; j++) {
        if (x[v][i] < cur) break;
        if (y[i][j] >= cur && vis[j] < tt) {
          ch(v, i, -cur);
          ch(i, j, cur);
          int go = dfs(j, cur);
          if (go) {
            return go;
          }
          ch(v, i, cur);
          ch(i, j, -cur);
        }
      }
    }
  }
  return 0;
}

struct triple {
  int u, v, go;
};

int main() {
#ifdef iq
  freopen("a.in", "r", stdin);
#endif
  ios::sync_with_stdio(0);
  cin.tie(0);
  cin >> n >> m;
  for (int i = 0; i < n; i++) {
    cin >> f[i];
    p[i] = i;
  }
  for (int i = 0; i < m; i++) {
    int a, b, cap;
    cin >> a >> b >> cap;
    a--, b--;
    x[a][b] = x[b][a] = cap;
  }
  vector <pair <int, int> > ee;
  for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
      //x[i][j] = x[j][i] = rnd() % 10;
      //int c = rnd() % (x[i][j] + 1);
      //f[i] += c, f[j] += c;
      ee.push_back({i, j});
    }
  }
  shuffle(ee.begin(), ee.end(), rnd);
  for (auto c : ee) {
    int i = c.first, j = c.second;
      if (f[i] && f[j]) {
        int grab = min(x[i][j], min(f[i], f[j]));
        f[i] -= grab, f[j] -= grab;
        ch(i, j, -grab);
      }
  }
  while (true) {
    vector <int> ord;
    for (int i = 0; i < n; i++) if (f[i]) ord.push_back(i);
    shuffle(ord.begin(), ord.end(), rnd);
    if (ord.empty()) break;
    int i = ord[0];
    s = i;
    for (int lg = (1 << 20); lg > 0; lg /= 2) {
      if (f[i] < lg) continue;
      tt++;
      while (int x = dfs(i, lg)) {
        f[i] -= x;
        if (f[i] < lg) break;
        tt++;
      }
    }
  }
  vector <triple> e;
  for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
      if (y[i][j]) {
        e.push_back({i + 1, j + 1, y[i][j]});
      }
    }
  }
  cout << e.size() << '\n';
  for (auto c : e) {
    cout << c.u << ' ' << c.v << ' ' << c.go << '\n';
  }
}