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

#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char *name, Arg1 &&arg1)
{
  cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&... args)
{
  const char *comma = strchr(names + 1, ',');
  cerr.write(names, comma - names) << " : " << arg1 << " | ";
  __f(comma + 1, args...);
}
#else
#define trace(...)
#endif

#define F first
#define S second
#define PB push_back
#define MP make_pair

#define FASTER                      \
  ios_base::sync_with_stdio(false); \
  cin.tie(NULL);                    \
  cout.tie(NULL);

using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
using vii = vector<ii>;
using vll = vector<ll>;

const int INF = 100000;

int main()
{
  FASTER;
  int t;
  cin >> t;
  while (t--)
  {
    int n;
    cin >> n;
    vector<int> Range(n);
    // Ri = range of i.
    for (int i = 0; i < n; i++)
    {
      cin >> Range[i];
      Range[i] += i;
    }
    // Cost[i][j].. is the number of k, i<=k<j to be set to '0' such that they can't reach j.  Cost[i][j] comes from Cost[i+1][j]. Cost[i][i] should be infinite.
    vector<vi> Cost(n, vi(n, INF));
    for (int j = n - 1; j > 0; j--)
    {
      Cost[j][j] = 0;
      for (int i = j - 1; i >= 0; i--)
      {
        Cost[i][j] = ((Range[i] >= j) ? 1 : 0) + Cost[i + 1][j];
      }
    }
    vector<vi> DP(n, vi(n, INF));
    /* 
      DP[i][j] = minimum cost such that there is exactly one way to start from i and the next jump is at j.
       i < j <= Range[i]
       Cost[i+1][j] has to be added to min(DP[j][k]) for all k st Range[i] < k <= Range[j]
       if Ri == n - 1 then, I have to go from i->n - 1.
    */

    DP[n - 1][n - 1] = 0;
    for (int i = n - 2; i >= 0; i--)
    {
      for (int j = Range[i]; j > i; j--)
      {
        int &dp = DP[i][j];
        if (j == n - 1)
        {
          dp = Cost[i + 1][n - 1];
          continue;
        }
        dp = DP[i][j + 1];
        if (Range[j] > Range[i])
          dp = min(dp, Cost[i + 1][j] + DP[j][Range[i] + 1]);
      }
    }
    cout << DP[0][1] << endl;
  }
  return 0;
}
