#include "bits/stdc++.h"

#define MOD 1000000007
#define rep(i, n) for(ll i=0; i < (n); i++)
#define rrep(i, n) for(ll i=(n)-1; i >=0; i--)
#define ALL(v) v.begin(),v.end()
#define rALL(v) v.rbegin(),v.rend()
#define FOR(i, j, k) for(ll i=j;i<k;i++)
#define debug_print(var) cerr << #var << "=" << var <<endl;
#define DUMP(i, v)for(ll i=0;i<v.size();i++)cerr<<v[i]<<" "
#define fi first
#define se second

using namespace std;
typedef long long int ll;
typedef vector<ll> llvec;
typedef vector<double> dvec;
typedef pair<ll, ll> P;
typedef long double ld;
struct edge{ll x, c;};

/*
  struct segment_tree{
  ll N;
  llvec v;
  ll init=5e18;//initial value
  ll f(ll a, ll b){ //function
  return min(a, b);
  }
  segment_tree(ll n){
  N=1;
  while(N<n){
  N*=2;
  }
  v = llvec(2*N-1, init);
  }
  
  void set(ll i, ll val){
  i += N-1;
  v[i] = val;
  while(i>0){
  i = (i-1)/2;
  v[i] = f(v[i*2+1], v[i*2+2]);
  }
  }
  void add(ll i, ll val){
  i += N-1;
  v[i] += val;
  while(i>0){
  i = (i-1)/2;
  v[i] = f(v[i*2+1], v[i*2+2]);
  }
  }

  ll get(ll L, ll R){// L <= i < R
  L += N-1;
  R += N-1;
  ll vl = init;
  ll vr = init;
  while(L<R){
  if(L%2==0){
  vl = f(vl, v[L]);
  L++;
  }
  if(R%2==0){
  vr = f(vr, v[R-1]);
  R--;
  }
  R=(R-1)/2;
  L=(L-1)/2;
  }
  return f(vl, vr);
  }

  ll operator[](ll i){
  return v[i+N-1];
  }
  
  };*/


template <class S, S (*op)(S, S), S (*e)()> struct segtree {
public:
  int ceil_pow2(int n) {
    int x = 0;
    while ((1U << x) < (unsigned int)(n)) x++;
    return x;
  }
  segtree() : segtree(0) {}
  segtree(int n) : segtree(std::vector<S>(n, e())) {}
  segtree(const std::vector<S>& v) : _n(int(v.size())) {
    log = ceil_pow2(_n);
    size = 1 << log;
    d = std::vector<S>(2 * size, e());
    for (int i = 0; i < _n; i++) d[size + i] = v[i];
    for (int i = size - 1; i >= 1; i--) {
      update(i);
    }
  }

  void set(int p, S x) {
    assert(0 <= p && p < _n);
    p += size;
    d[p] = x;
    for (int i = 1; i <= log; i++) update(p >> i);
  }

  S get(int p) {
    assert(0 <= p && p < _n);
    return d[p + size];
  }

  S prod(int l, int r) {
    assert(0 <= l && l <= r && r <= _n);
    S sml = e(), smr = e();
    l += size;
    r += size;

    while (l < r) {
      if (l & 1) sml = op(sml, d[l++]);
      if (r & 1) smr = op(d[--r], smr);
      l >>= 1;
      r >>= 1;
    }
    return op(sml, smr);
  }

  S all_prod() { return d[1]; }

  template <bool (*f)(S)> int max_right(int l) {
    return max_right(l, [](S x) { return f(x); });
  }
  template <class F> int max_right(int l, F f) {
    assert(0 <= l && l <= _n);
    assert(f(e()));
    if (l == _n) return _n;
    l += size;
    S sm = e();
    do {
      while (l % 2 == 0) l >>= 1;
      if (!f(op(sm, d[l]))) {
        while (l < size) {
          l = (2 * l);
          if (f(op(sm, d[l]))) {
            sm = op(sm, d[l]);
            l++;
          }
        }
        return l - size;
      }
      sm = op(sm, d[l]);
      l++;
    } while ((l & -l) != l);
    return _n;
  }

  template <bool (*f)(S)> int min_left(int r) {
    return min_left(r, [](S x) { return f(x); });
  }
  template <class F> int min_left(int r, F f) {
    assert(0 <= r && r <= _n);
    assert(f(e()));
    if (r == 0) return 0;
    r += size;
    S sm = e();
    do {
      r--;
      while (r > 1 && (r % 2)) r >>= 1;
      if (!f(op(d[r], sm))) {
        while (r < size) {
          r = (2 * r + 1);
          if (f(op(d[r], sm))) {
            sm = op(d[r], sm);
            r--;
          }
        }
        return r + 1 - size;
      }
      sm = op(d[r], sm);
    } while ((r & -r) != r);
    return 0;
  }

private:
  int _n, size, log;
  std::vector<S> d;

  void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};

using S = ll;

S op(S a, S b){
  return a+b;
}
S e(){
  return 0;
}

S op2(S a, S b){
  return max(a, b);
}

S e2(){
  return -1;
}

//segtree<S, op, e> sg(vector<S> a)
using PP = pair<P, ll>;

/**************************************
** A main function starts from here  **
***************************************/
int main(){
  ll N, Q;
  cin >> N >> Q;
  llvec a(N, 0);
  llvec a2(N, -1);
  segtree<S, op2, e2> sg2(a2);
  vector<ll> loc(N);
  vector<P> val(N);

  rep(i, N){
    ll t;
    cin >> t;

    ll tmp = sg2.prod(t, N);

    //cerr << t << " " << tmp <<" " << i<< endl;
    tmp = min(i, tmp);
    sg2.set(t-1, i);
    val[i] = {tmp, i};
  }
  sort(ALL(val));
  segtree<S, op, e> sg(a);
  vector<PP> que;
  llvec ans(Q, 0);
  rep(i, Q){
    ll t, l, r;
    cin >> t >> l >> r;
    que.push_back({{l, r}, i});
  }
  sort(ALL(que));
  ll l = 0;
  for(auto iq: que){
    while(l<N and iq.fi.fi-1>val[l].fi){
      sg.set(val[l].se, 1);
      l++;
    }
    ans[iq.se] = sg.prod(iq.fi.fi-1, iq.fi.se);
  }
  for(auto iq: ans){
    cout << iq << endl;
  }
  return 0;
}