// qdd on Feb 12, 2023

#ifdef qdd
#include <ringo>
#else
#include <bits/stdc++.h>
#define dbg(...)
#define dbgr(x, y)
#endif

using namespace std;

using ll = long long;

#define ALL(x) begin(x), end(x)

template <class T>
istream& operator>>(istream& is, vector<T>& v) {
  for (T& x : v) is >> x;
  return is;
}

template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
  bool f = 0;
  for (const T& x : v) (f ? os << ' ' : os) << x, f = 1;
  return os;
}

// repeating elements with same id
template <class T>
vector<int> unique_dc(const vector<T>& a, int start_id) {
  int n = a.size();
  vector<T> t(a);
  sort(t.begin(), t.end());
  t.resize(unique(t.begin(), t.end()) - t.begin());
  vector<int> id(n);
  for (int i = 0; i < n; i++) {
    id[i] = start_id + lower_bound(t.begin(), t.end(), a[i]) - t.begin();
  }
  return id;
}

struct fenwick {
  int n;
  vector<int> t;
  fenwick(int n) : n(n), t(n + 1) {}
  void add(int p, int x) {
    for (; p <= n; p += p & -p) t[p] += x;
  }
  int get(int p) {
    int a = 0;
    for (; p > 0; p -= p & -p) a += t[p];
    return a;
  }
};

void sol() {
  int n, k;
  cin >> n >> k;
  vector<int> a(n);
  cin >> a;
  a = unique_dc(a, 1);
  int mx = *max_element(ALL(a));
  // inv between [0, i-1] and [i,n-1]
  vector<int> inv(n + 1);
  auto build_inverse = [&](int l, int r) {
    if (r - l < 5) {
      for (int k = l; k <= r; k++) {
        inv[k] = 0;
        for (int i = l; i < k; i++) {
          for (int j = k; j <= r; j++) {
            if (a[i] > a[j]) inv[k]++;
          }
        }
      }
      return;
    }
    fenwick L(mx), R(mx);
    for (int i = l; i <= r; i++) {
      R.add(a[i], 1);
    }
    inv[l] = 0;
    for (int i = l + 1; i <= r; i++) {
      R.add(a[i - 1], -1);
      inv[i] = inv[i - 1] + R.get(a[i - 1] - 1) - (L.get(mx) - L.get(a[i - 1]));
      L.add(a[i - 1], 1);
    }
    inv[r + 1] = 0;
  };
  build_inverse(0, n - 1);
  auto global_inverse = [&]() {
    fenwick t(mx);
    int res = 0;
    for (int i = 0; i < n; i++) {
      res += t.get(mx) - t.get(a[i]);
      t.add(a[i], 1);
    }
    return res;
  };
  int ans = global_inverse();
  for (int i = 0; i < k; i++) {
    int p = max_element(ALL(inv)) - inv.begin();
    ans -= inv[p];
    int l = p - 1, r = p;
    while (inv[l] > 0) l--;
    while (inv[r] > 0) r++;
    build_inverse(l, p - 1);
    build_inverse(p, r - 1);
  }
  cout << ans << '\n';
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  int T;
  cin >> T;
  while (T--) {
    sol();
  }
  return 0;
}