#include <bits/stdc++.h>

using namespace std;
using i64 = long long;

#ifdef LOCAL
#include "algo/debug.h"
#else 
#define debug(...) 42
#endif

struct Node {
  Node *l = nullptr;
  Node *r = nullptr;
  int cnt = 0;
  i64 sum = 0;
  Node() : l{}, r{}, cnt{}, sum{} {}
};

Node *add(Node *t, int l, int r, int x, int v) {
  Node *nt = new Node();
  if (t) {
    *nt = *t;
  }
  nt->cnt += 1;
  nt->sum += v;
  if (r - l > 1) {
    int m = (l + r) / 2;
    if (m > x) {
      nt->l = add(nt->l, l, m, x, v);
    } else {
      nt->r = add(nt->r, m, r, x, v);
    }
  }
  return nt;
}

int kth(Node *t1, Node *t2, int l, int r, int k) {
  if (r - l == 1) {
    return l;
  }
  int cnt = (t2 && t2->l ? t2->l->cnt : 0) - (t1 && t1->l ? t1->l->cnt : 0);
  int m = (l + r) / 2;
  if (cnt >= k) {
    return kth(t1 ? t1->l : nullptr, t2 ? t2->l : nullptr, l, m, k);
  } else {
    return kth(t1 ? t1->r : nullptr, t2 ? t2->r : nullptr, m, r, k - cnt);
  }
}

pair<int, i64> operator+(const pair<int, i64> &lhs, const pair<int, i64> &rhs) {
  return make_pair(lhs.first + rhs.first, lhs.second + rhs.second);
}

pair<int, i64> query(Node *t1, Node *t2, int l, int r, int x, int y) {
  if (l >= x && r <= y) {
    return make_pair((t2 ? t2->cnt : 0) - (t1 ? t1->cnt : 0), (t2 ? t2->sum : 0) - (t1 ? t1->sum : 0));
  }
  if (l >= y || r <= x) {
    return make_pair(0, 0);
  }
  int m = (l + r) / 2;
  return query(t1 ? t1->l : nullptr, t2 ? t2->l : nullptr, l, m, x, y) + query(t1 ? t1->r : nullptr, t2 ? t2->r : nullptr, m, r, x, y);
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  int tt;
  cin >> tt;
  while (tt--) {
    int n;
    i64 k;
    cin >> n >> k;
    vector<int> a(n);
    for (int i = 0; i < n; i++) {
      cin >> a[i];
      a[i] -= i;
    }
    auto v = a;
    sort(v.begin(), v.end());
    v.erase(unique(v.begin(), v.end()), v.end());
    const int m = (int) v.size();
    vector<int> b(n);
    for (int i = 0; i < n; i++) {
      b[i] = lower_bound(v.begin(), v.end(), a[i]) - v.begin();
    }
    vector<Node *> node(n + 1);
    for (int i = 0; i < n; i++) {
      node[i + 1] = add(node[i], 0, m, b[i], a[i]);
    }
    debug(a);
    auto calc = [&](int x) {
      i64 ans = 1e18;
      const int s = (x + 1) / 2;
      for (int i = 0; i + x <= n; i++) {
        int p = kth(node[i], node[i + x], 0, m, s);
        // debug(v[p]);
        auto [c1, s1] = query(node[i], node[i + x], 0, m, 0, p);
        auto [c2, s2] = query(node[i], node[i + x], 0, m, p, m);
        i64 res = 1LL * v[p] * c1 - s1 + s2 - 1LL * v[p] * c2;
        ans = min(ans, res);
      }
      // debug(x, ans);
      return ans;
    };
    int low = 1, high = n;
    int ans = 1;
    while (low <= high) {
      int mid = (low + high) / 2;
      if (calc(mid) <= k) {
        ans = mid;
        low = mid + 1;
      } else {
        high = mid - 1;
      }
    }
    cout << ans << '\n';
  }
  return 0; 
}