```go
package main

import (
	"bufio"
	"os"
	"strconv"
)

func main() {
	// Configure fast I/O
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	// Helper function to read next integer
	nextInt := func() int {
		scanner.Scan()
		data := scanner.Bytes()
		val := 0
		for _, b := range data {
			val = val*10 + int(b-'0')
		}
		return val
	}

	// Read n
	// Manual first scan to handle n
	if !scanner.Scan() {
		return
	}
	nRaw := scanner.Bytes()
	n := 0
	for _, b := range nRaw {
		n = n*10 + int(b-'0')
	}

	// Read array a (1-based index)
	a := make([]int, n+1)
	for i := 1; i <= n; i++ {
		a[i] = nextInt()
	}

	// Read q
	q := nextInt()
	ans := make([]int, q)

	// Square root decomposition threshold
	const B = 320 // Approximately sqrt(100000)

	type query struct {
		p, id int
	}
	// Buckets for offline processing of small k
	queries := make([][]query, B)

	for i := 0; i < q; i++ {
		p := nextInt()
		k := nextInt()

		if k >= B {
			// Large k: simulate directly
			count := 0
			curr := p
			for curr <= n {
				count++
				curr = curr + a[curr] + k
			}
			ans[i] = count
		} else {
			// Small k: defer processing
			queries[k] = append(queries[k], query{p, i})
		}
	}

	// Process small k queries using DP
	dp := make([]int, n+1)
	for k := 1; k < B; k++ {
		if len(queries[k]) == 0 {
			continue
		}
		// Compute steps for all positions for this k
		for i := n; i >= 1; i-- {
			nxt := i + a[i] + k
			if nxt > n {
				dp[i] = 1
			} else {
				dp[i] = 1 + dp[nxt]
			}
		}
		// Answer deferred queries
		for _, qry := range queries[k] {
			ans[qry.id] = dp[qry.p]
		}
	}

	// Print answers
	for i := 0; i < q; i++ {
		out.WriteString(strconv.Itoa(ans[i]))
		out.WriteByte('\n')
	}
}
```