#include<iostream>
#include<fstream>
#include<random>

using namespace std;

const int MAXN = 1e5 + 5;
const int maxLog = 17;

int n;
int a[MAXN];

int logValue[MAXN*2];

struct segmentTree
{
    int l, r;
    int maxValue;
    segmentTree *L, *R;

    segmentTree(int l, int r, int value)
    {
        this->l = l;
        this->r = r;
        this->maxValue = value;

        this->L = nullptr;
        this->R = nullptr;
    }

    void build(int l, int r, int a[])
    {
        if(l==r)
        {
            this->maxValue = a[l];
            return;
        }

        this->L = new segmentTree(l, (l+r)/2, -1);
        this->R = new segmentTree((l+r)/2+1, r, -1);

        this->L->build(l, (l+r)/2, a);
        this->R->build((l+r)/2+1, r, a);
        this->maxValue = max(this->L->maxValue, this->R->maxValue);
    }

    int query(int ql, int qr)
    {
        if(this->l>=ql && r<=qr) return this->maxValue;
        if(this->r<ql || this->l>qr) return -1;

        return max(this->L->query(ql, qr), this->R->query(ql, qr));
    }
};

int sparse[20][MAXN];
int maxTable[20][MAXN];

void makeSparse(int a[])
{
    for(int i = 0;i<n;i++)
    {
        maxTable[0][i] = a[i];
    }
    for(int i = 1;i<maxLog;i++)
    {
        for(int j = 0;j<n;j++)
        {
            maxTable[i][j] = max(maxTable[i-1][j], maxTable[i-1][ j + ( 1 << (i-1) )]);
        }
    }
}

int getMax(int l, int r)
{
    return max(maxTable[ logValue[r-l+1] - 1 ][l], maxTable[ logValue[r-l+1] - 1 ][ r - (1<<(logValue[r-l+1]-1)) + 1 ]);
}

void initLog()
{
    int value = 2;

    logValue[0] = 0;
    logValue[1] = 1;
    for(int i = 2;i<=n*2;i++)
    {
        logValue[i] = logValue[i-1];

        if(value<=i)
        {
            value *= 2;
            logValue[i]++;
        }
    }
}

segmentTree *T[20];

void precalc()
{
    for(int i = 0;i<maxLog;i++)
    {
        T[i] = new segmentTree(0, n-1, 0);
    }
    for(int i = 0;i<n;i++)
    {
        sparse[0][i] = a[i];
    }

    makeSparse(sparse[0]);
    T[0]->build(0, n-1, sparse[0]);

    for(int i = 1;i<maxLog;i++)
    {
        for(int j = 0;j<n;j++)
        {
            sparse[i][j] = getMax(j, min(sparse[i-1][j], n-1));
        }

        makeSparse(sparse[i]);
        T[i]->build(0, n-1, sparse[i]);
    }
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);cout.tie(NULL);

    ifstream cin("jumps.in");
    ofstream cout("jumps.out");

    int Q;
    int l, r;
    int current = 0, answer = 0;

    cin >> n;
    for(int i = 0;i<n;i++)
    {
        cin >> a[i];
        a[i] += i;
    }

    initLog();
    precalc();

    cin >> Q;
    while(Q--)
    {
        cin >> l >> r;

        l--;
        r--;

        answer = 0;
        current = l;
        for(int i = maxLog-1;i>=0;i--)
        {
            int x = T[i]->query(l, current);
            if(x<r)
            {
                current = x;
                answer += (1<<i);
            }
        }

        cout << answer + 1 << '\n';
    }
}