#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


//      k[0]    k[1]  ...       k[n-1]=kLim
// ------)[------)[-  ...  -)[------)[unpainted
//  v[0]    v[1]              v[n-1]
template <class K, class V> struct Painter : map<K, V> {
  const K kLim;
  Painter(K k, const V &v) : map<K, V>{{k, v}}, kLim(k) {}
  // Paint [a, b) with v, calling f(left, right, (old color)).
  template <class F> void paint(K a, K b, const V &v, F f) {
    assert(a < b); assert(b < kLim);
    auto it = this->lower_bound(a);
    if (b < it->first) {
      f(a, b, it->second);
      this->emplace(a, it->second);
      this->emplace(b, v);
    } else if (a < it->first) {
      const V va = it->second;
      K k = a;
      for (; it->first <= b; it = this->erase(it)) {
        f(k, it->first, it->second);
        k = it->first;
      }
      if (k < b) {
        f(k, b, it->second);
      }
      this->emplace(a, va);
      this->emplace(b, v);
    } else {
      ++it;
      K k = a;
      for (; it->first <= b; it = this->erase(it)) {
        f(k, it->first, it->second);
        k = it->first;
      }
      if (k < b) {
        f(k, b, it->second);
      }
      this->emplace(b, v);
    }
  }
  void paint(K a, K b, const V &v) {
    paint(a, b, v, [&](K, K, const V &) -> void {});
  }
  V get(K k) const {
    assert(k < kLim);
    return this->upper_bound(k)->second;
  }
};

////////////////////////////////////////////////////////////////////////////////


int N, Q;
vector<int> A;
vector<int> L, R, X;

Int sumA;


namespace brute {
vector<int> run() {
  vector<vector<int>> ques(N);
  vector<int> poss(N, 0);
  for (int i = 0; i < N; ++i) {
    ques[i].assign(A[i], 0);
  }
  const int limX = *max_element(X.begin(), X.end()) + 1;
  vector<int> now(limX, 0);
  vector<int> ans(Q, 0);
  for (int q = 0; q < Q; ++q) {
    for (int i = L[q]; i < R[q]; ++i) {
      --now[ques[i][poss[i]]];
      ++now[ques[i][poss[i]] = X[q]];
      if (++poss[i] == A[i]) poss[i] = 0;
    }
    for (int x = 1; x < limX; ++x) if (now[x]) {
      ++ans[q];
    }
  }
  return ans;
}
}  // brute


namespace slow {
vector<int> run() {
  const int K = max<int>(sqrt(sumA / 1000), 1);
cerr<<"K = "<<K<<endl;
  vector<int> large;
  vector<vector<int>> small(K);
  for (int i = 0; i < N; ++i) {
    if (A[i] > K) {
      large.push_back(i);
    } else {
      for (int k = 0; k < A[i]; ++k) {
        small[k].push_back(i);
      }
    }
  }
  
  vector<vector<int>> ques(N);
  vector<int> poss(N, 0);
  for (const int i : large) {
    ques[i].assign(A[i], -1);
  }
  vector<Painter<int, int>> painters(K, Painter<int, int>(N + 1, -1));
  
  const int limX = *max_element(X.begin(), X.end()) + 1;
  vector<Int> now(limX, 0);
  int kind = 0;
  auto add = [&](int x, Int val) -> void {
    if (now[x]) --kind;
    now[x] += val;
    if (now[x]) ++kind;
  };
  
  vector<int> ans(Q, 0);
  for (int q = 0; q < Q; ++q) {
    for (const int i : large) if (L[q] <= i && i < R[q]) {
      int &x = ques[i][poss[i]];
      if (~x) add(x, -1);
      add(x = X[q], +1);
      if (++poss[i] == A[i]) poss[i] = 0;
    }
    {
      vector<pair<pair<int, int>, int>> crt;
      crt.emplace_back(make_pair(L[q], R[q]), q);
      for (int k = 0; k < K; ++k) {
        vector<pair<pair<int, int>, int>> nxt;
        for (const auto &p : crt) {
          const int l = lower_bound(small[k].begin(), small[k].end(), p.first.first) - small[k].begin();
          const int r = lower_bound(small[k].begin(), small[k].end(), p.first.second) - small[k].begin();
          if (l < r) {
            painters[k].paint(l, r, p.second, [&](int ll, int rr, int qq) -> void {
              if (~qq && ll < rr) {
                add(X[qq], -(rr - ll));
                nxt.emplace_back(make_pair(small[k][ll], small[k][rr - 1] + 1), qq);
              }
            });
            add(X[p.second], +(r - l));
          }
        }
        crt.swap(nxt);
      }
    }
    ans[q] = kind;
  }
  return ans;
}
}  // slow


int main() {
  for (; ~scanf("%d%d", &N, &Q); ) {
    A.resize(N);
    for (int i = 0; i < N; ++i) {
      scanf("%d", &A[i]);
    }
    L.resize(Q);
    R.resize(Q);
    X.resize(Q);
    for (int q = 0; q < Q; ++q) {
      scanf("%d%d%d", &L[q], &R[q], &X[q]);
      --L[q];
    }
    
    sumA = 0;
    for (int i = 0; i < N; ++i) sumA += A[i];
    
    vector<int> ans;
    // if (*max_element(A.begin(), A.end()) <= 10) {
    if (sumA <= 1'000'000) {
      ans = slow::run();
    } else {
      ans = brute::run();
    }
    
    for (int q = 0; q < Q; ++q) {
      printf("%d\n", ans[q]);
    }
  }
  return 0;
}