#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")


template <class T> void bAdd(vector<T> &bit, int pos, const T &val) {
  const int bitN = bit.size();
  for (int x = pos; x < bitN; x |= x + 1) bit[x] += val;
}
template <class T> T bSum(const vector<T> &bit, int pos) {
  T ret = 0;
  for (int x = pos; x > 0; x &= x - 1) ret += bit[x - 1];
  return ret;
}
template <class T> T bSum(const vector<T> &bit, int pos0, int pos1) {
  return bSum(bit, pos1) - bSum(bit, pos0);
}

// min pos s.t. pred(sum of [0, pos))
//   assume pred(sum of [0, pos)) is non-decreasing
template <class T, class Pred>
int bBinarySearch(const vector<T> &bit, Pred pred) {
  if (pred(T(0))) return 0;
  const int bitLen = bit.size();
  int pos = 0;
  T sum = 0;
  for (int e = 31 - __builtin_clz(bitLen); e >= 0; --e) {
    const int x = (pos | 1 << e) - 1;
    if (x < bitLen && !pred(sum + bit[x])) {
      pos |= 1 << e;
      sum += bit[x];
    }
  }
  return pos + 1;
}


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


namespace brute {
vector<int> run() {
cerr<<"[brute::run]"<<endl;
  vector<int> ans(Q, 0);
  for (int q = 0; q < Q; ++q) {
    vector<int> bs(A.begin() + L[q], A.begin() + R[q]);
    sort(bs.begin(), bs.end(), greater<int>{});
    int mn = N;
    for (int i = 0; i < R[q] - L[q]; ++i) {
      chmin(mn, A[L[q] + i]);
      if (mn < bs[i]) {
        ++ans[q];
      }
    }
  }
  return ans;
}
}  // brute


namespace fast {
vector<int> run() {
cerr<<"[fast::run]"<<endl;
  vector<int> ans(Q, 0);
  vector<vector<int>> qss(N);
  for (int q = 0; q < Q; ++q) {
    qss[L[q]].push_back(q);
  }
  
  /*
    es[l] = (r, t)
    t-th (1-based) index >= r s.t. A[*] > A[l]
  */
  vector<pair<int, int>> es(N);
  vector<int> ks(N);
  for (int phase = 0; phase < 2; ++phase) {
    // stack for prefix min
    int top = 0;
    vector<int> is(N + 1);
    vector<vector<int>> jss(N + 1);
    vector<int> fulls(N + 1);
    is[0] = N;
    fulls[0] = 0;
    vector<int> bitCost(N + 1, 0);
    for (int l = N; --l >= 0; ) {
      for (; A[l] < A[is[top]]; --top) {
        if (phase == 1) {
          for (const int j : jss[top]) {
            bAdd(bitCost, ks[j], -1);
          }
        }
      }
      if (A[l] > A[is[top]]) {
        ++top;
        is[top] = l;
        jss[top] = {l};
      } else {
        is[top] = l;
        jss[top].push_back(l);
      }
// cerr<<"l = "<<l<<": is = "<<vector<int>(is.begin(),is.begin()+(top+1))<<", jss = "<<vector<vector<int>>(jss.begin(),jss.begin()+(top+1))<<endl;
      if (phase == 0) {
        es[l] = make_pair(is[top - 1], (int)jss[top].size());
      }
      if (phase == 1) {
        bAdd(bitCost, ks[l], +1);
        fulls[top] = ((is[top - 1] - is[top]) - (int)jss[top].size()) + fulls[top - 1];
        for (const int q : qss[l]) {
          const int pos = partition_point(is.begin(), is.begin() + (top + 1), [&](int i) -> bool {
            return (i >= R[q]);
          }) - is.begin();
          assert(top >= pos); assert(pos >= 0);
          assert(is[pos] < R[q]); assert(R[q] <= is[pos - 1]);
          ans[q] += (fulls[top] - fulls[pos]);
          ans[q] += bSum(bitCost, R[q]);
          const int num = partition_point(jss[pos].begin(), jss[pos].end(), [&](int j) -> bool {
            return (j >= R[q]);
          }) - jss[pos].begin();
          ans[q] += (R[q] - is[pos]) - ((int)jss[pos].size() - num);
        }
      }
    }
    if (phase == 0) {
      vector<vector<int>> lss(N);
      for (int l = 0; l < N; ++l) {
        lss[A[l]].push_back(l);
      }
      vector<int> bitLarger(N, 0);
      for (int a = N; --a >= 0; ) {
        for (const int l : lss[a]) {
          const int r = es[l].first;
          const int t = es[l].second;
          const int sumR = bSum(bitLarger, r);
          ks[l] = min(bBinarySearch(bitLarger, [&](int s) -> bool {
            return (s >= sumR + t);
          }) - 1, N);
          bAdd(bitLarger, l, +1);
        }
      }
// cerr<<"es = "<<es<<", ks = "<<ks<<endl;
    }
  }
  return ans;
}
}  // fast


int main() {
  for (; ~scanf("%d%d", &N, &Q); ) {
    A.resize(N + 1);
    for (int i = 0; i < N; ++i) {
      scanf("%d", &A[i]);
      --A[i];
    }
    A[N] = -1;
    L.resize(Q);
    R.resize(Q);
    for (int q = 0; q < Q; ++q) {
      scanf("%d%d", &L[q], &R[q]);
      --L[q];
    }
    
    const auto ans = fast::run();
    for (int q = 0; q < Q; ++q) {
      printf("%d\n", ans[q]);
    }
#ifdef LOCAL
const auto brt=brute::run();
for(int q=0;q<Q;++q)if(brt[q]!=ans[q]){
 cerr<<A<<" "<<L[q]<<" "<<R[q]<<": "<<vector<int>(A.begin()+L[q],A.begin()+R[q])<<" "<<brt[q]<<" "<<ans[q]<<endl;
 break;
}
assert(brt==ans);
#endif
  }
  return 0;
}