#include <bits/stdc++.h>
using namespace std;

#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);
using ll = long long;

template<typename T>
struct SparseTable {
  vector<vector<T>> table;
  vector<int> lg;
  int n, lg_n;

  T merge(T a, T b) {
    return max(a, b);
  }

  SparseTable() {}

  template<typename DATA_T>
  SparseTable(vector<DATA_T>& arr) {
    n = arr.size();
    lg_n = 1 + (int)log2(n);
    table = vector<vector<T>>(lg_n+1, vector<T>(n));
    lg = vector<int>(n+1, 0);
    for (int i = 2; i <= n; ++i) lg[i] = 1+lg[i>>1];

    int i, j, k;
    for (i = 0; i < n; ++i) table[0][i] = arr[i];
    for (j = 1; j <= lg_n; ++j) {
      k = n-(1<<j);
      for (i = 0; i <= k; ++i) {
        table[j][i] = merge(table[j-1][i], table[j-1][i+(1<<(j-1))]);
      }
    }
  }

  T query(int l, int r) {
    int i = lg[r-l+1];
    return merge(table[i][l], table[i][r-(1<<i)+1]);
  }
};

const int MX = 200005;
vector<int> pos[MX];
SparseTable<int> sp;

ll solve(ll l, ll r) {
  if (l >= r) return 0;

  ll x, m, p, i, j, ans;
  x = sp.query(l, r);
  j = lower_bound(pos[x].begin(), pos[x].end(), l) - pos[x].begin();
  m = pos[x].size();
  i = pos[x][j];
  ans = i-l + solve(l, i-1);
  for (j = j+1; j < m; ++j) {
    p = i;
    i = pos[x][j];
    ans += min(i, r) - p - 1 + solve(p+1, i-1);
    if (i >= r) break;
  }

  return ans;
}

template<typename T>
vector<T> normalize(vector<T>& a, T start = 0) {
  int n = a.size();
  vector<T> b = a;
  sort(b.begin(), b.end());
  b.erase(unique(b.begin(), b.end()), b.end());
  vector<T> ret(n, start);
  for (int i = 0; i < n; ++i) {
    ret[i] += lower_bound(b.begin(), b.end(), a[i]) - b.begin();
  }
  return ret;
}

int main() {
  FAST;
  
  int tc = 1, ti;
  cin >> tc;

  for (ti = 1; ti <= tc; ++ti) {
    int n, i;
    cin >> n;

    vector<int> a(n);
    for (i = 0; i < n; ++i) cin >> a[i];
    a = normalize(a);
    sp = SparseTable<int>(a);

    for (i = 0; i < n; ++i) pos[i].clear();

    for (i = 0; i < n; ++i) {
      pos[a[i]].emplace_back(i);
    }

    cout << solve(0, n-1) << "\n";
  }

  return 0;
}