```go
package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	nextInt := func() int {
		scanner.Scan()
		val, _ := strconv.Atoi(scanner.Text())
		return val
	}

	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())

	if n == 1 {
		nextInt()
		out := bufio.NewWriter(os.Stdout)
		out.WriteString("0\n")
		out.Flush()
		return
	}

	r := make([]int32, n)
	for i := 0; i < n; i++ {
		r[i] = int32(nextInt())
	}

	N := 3 * n
	var L [18][]int32
	var R [18][]int32
	for i := 0; i < 18; i++ {
		L[i] = make([]int32, N)
		R[i] = make([]int32, N)
	}

	var st_min [19][]int32
	var st_max [19][]int32
	for i := 0; i < 19; i++ {
		st_min[i] = make([]int32, N)
		st_max[i] = make([]int32, N)
	}

	log2 := make([]int32, N+1)
	log2[1] = 0
	for i := 2; i <= N; i++ {
		log2[i] = log2[i/2] + 1
	}

	for i := 0; i < N; i++ {
		L[0][i] = int32(i) - r[i%n]
		if L[0][i] < 0 {
			L[0][i] = 0
		}
		R[0][i] = int32(i) + r[i%n]
		if R[0][i] >= int32(N) {
			R[0][i] = int32(N - 1)
		}
	}

	for p := 1; p < 18; p++ {
		for i := 0; i < N; i++ {
			st_min[0][i] = L[p-1][i]
			st_max[0][i] = R[p-1][i]
		}
		for j := 1; (1 << j) <= N; j++ {
			for i := 0; i+(1<<j) <= N; i++ {
				a := st_min[j-1][i]
				b := st_min[j-1][i+(1<<(j-1))]
				if a < b {
					st_min[j][i] = a
				} else {
					st_min[j][i] = b
				}

				c := st_max[j-1][i]
				d := st_max[j-1][i+(1<<(j-1))]
				if c > d {
					st_max[j][i] = c
				} else {
					st_max[j][i] = d
				}
			}
		}

		for i := 0; i < N; i++ {
			l := L[p-1][i]
			ri := R[p-1][i]
			k := log2[ri-l+1]

			a := st_min[k][l]
			b := st_min[k][ri-(1<<k)+1]
			if a < b {
				L[p][i] = a
			} else {
				L[p][i] = b
			}

			c := st_max[k][l]
			d := st_max[k][ri-(1<<k)+1]
			if c > d {
				R[p][i] = c
			} else {
				R[p][i] = d
			}
		}
	}

	curL := make([]int32, n)
	curR := make([]int32, n)
	ans := make([]int32, n)
	for i := 0; i < n; i++ {
		curL[i] = int32(i + n)
		curR[i] = int32(i + n)
		ans[i] = 0
	}

	for p := 17; p >= 0; p-- {
		for i := 0; i < N; i++ {
			st_min[0][i] = L[p][i]
			st_max[0][i] = R[p][i]
		}
		for j := 1; (1 << j) <= N; j++ {
			for i := 0; i+(1<<j) <= N; i++ {
				a := st_min[j-1][i]
				b := st_min[j-1][i+(1<<(j-1))]
				if a < b {
					st_min[j][i] = a
				} else {
					st_min[j][i] = b
				}

				c := st_max[j-1][i]
				d := st_max[j-1][i+(1<<(j-1))]
				if c > d {
					st_max[j][i] = c
				} else {
					st_max[j][i] = d
				}
			}
		}

		for i := 0; i < n; i++ {
			l := curL[i]
			ri := curR[i]
			k := log2[ri-l+1]

			a := st_min[k][l]
			b := st_min[k][ri-(1<<k)+1]
			nextL := a
			if b < a {
				nextL = b
			}

			c := st_max[k][l]
			d := st_max[k][ri-(1<<k)+1]
			nextR := c
			if d > c {
				nextR = d
			}

			if nextR-nextL < int32(n-1) {
				curL[i] = nextL
				curR[i] = nextR
				ans[i] += 1 << p
			}
		}
	}

	out := bufio.NewWriter(os.Stdout)
	for i := 0; i < n; i++ {
		out.WriteString(strconv.Itoa(int(ans[i] + 1)))
		if i != n-1 {
			out.WriteByte(' ')
		}
	}
	out.WriteByte('\n')
	out.Flush()
}
```