Problem:
Score : 700 points

Problem Statement

N hotels are located on a straight line. The coordinate of the i-th hotel (1 \leq i \leq N) is x_i.

Tak the traveler has the following two personal principles:

He never travels a distance of more than L in a single day.

He never sleeps in the open. That is, he must stay at a hotel at the end of a day.

You are given Q queries. The j-th (1 \leq j \leq Q) query is described by two distinct integers a_j and b_j.
For each query, find the minimum number of days that Tak needs to travel from the a_j-th hotel to the b_j-th hotel following his principles.
It is guaranteed that he can always travel from the a_j-th hotel to the b_j-th hotel, in any given input.

Constraints

2 \leq N \leq 10^5

1 \leq L \leq 10^9

1 \leq Q \leq 10^5

1 \leq x_i < x_2 < ... < x_N \leq 10^9

x_{i+1} - x_i \leq L

1 \leq a_j,b_j \leq N

a_j \neq b_j

N,\,L,\,Q,\,x_i,\,a_j,\,b_j are integers.

Partial Score

200 points will be awarded for passing the test set satisfying N \leq 10^3 and Q \leq 10^3.

Input

The input is given from Standard Input in the following format:

N
x_1 x_2 ... x_N
L
Q
a_1 b_1
a_2 b_2
:
a_Q b_Q

Output

Print Q lines.
The j-th line (1 \leq j \leq Q) should contain the minimum number of days that Tak needs to travel from the a_j-th hotel to the b_j-th hotel.

Sample Input 1

9
1 3 6 13 15 18 19 29 31
10
4
1 8
7 3
6 7
8 5

Sample Output 1

4
2
1
2

For the 1-st query, he can travel from the 1-st hotel to the 8-th hotel in 4 days, as follows:

Day 1: Travel from the 1-st hotel to the 2-nd hotel. The distance traveled is 2.

Day 2: Travel from the 2-nd hotel to the 4-th hotel. The distance traveled is 10.

Day 3: Travel from the 4-th hotel to the 7-th hotel. The distance traveled is 6.

Day 4: Travel from the 7-th hotel to the 8-th hotel. The distance traveled is 10.

Solution in Rust (1.15.1) (judge verdict: Runtime Error)

use std::collections::VecDeque;

fn doubling(x: &Vec<usize>, l: usize) -> Vec<Vec<usize>> {
    let n = x.len();
    let mut t = vec![vec![0; 32]; n];
    let mut q = VecDeque::new();
    q.push_back(0);
    for i in 1..n {
        while let Some(h) = q.pop_front() {
            if x[i] - x[h] > l {
                t[h][0] = i - 1;
            } else {
                q.push_front(h);
                break;
            }
        }
        q.push_back(i);
    }
    while let Some(h) = q.pop_front() {
        t[h][0] = n - 1;
    }

    for bit in 0..31 {
        for i in 0..n {
            t[i][bit + 1] = t[t[i][bit]][bit];
        }
    }
    t
}

fn query(t: &Vec<Vec<usize>>, a: usize, b: usize) -> usize {
    let mut cur = a;
    let mut ans = 0;
    for i in (1..32).rev() {
        if t[cur][i - 1] >= b {
            continue;
        }
        cur = t[cur][i];
        ans += 1 << i;
    }
    while cur < b {
        cur = t[cur][0];
        ans += 1;
    }
    ans
}

fn check(day: usize, from: usize, t: &Vec<Vec<usize>>) -> usize {
    let mut cur = from;
    for i in 0..32 {
        if day & (1 << i) != 0 {
            cur = t[cur][i];
        }
    }
    cur
}

fn main() {
    let mut sc = Scanner::new();
    let n = sc.read();
    let x: Vec<usize> = sc.read_vec(n);
    let l = sc.usize_read();

    let forward = doubling(&x, l);
    let x = x.iter().rev().map(|y| x[n - 1] - y).collect();
    let backward = doubling(&x, l);

    let q: usize = sc.read();
    for _ in 0..q {
        let a = sc.usize_read() - 1;
        let b = sc.usize_read() - 1;
        let ans = if a < b {
            query(&forward, a, b)
        } else {
            query(&backward, n - 1 - a, n - 1 - b)
        };
        println!("{}", ans);
        if a < b {
            assert!(check(ans, a, &forward) >= b);
            assert!(check(ans - 1, a, &forward) < b);
        }
    }
}

struct Scanner {
    ptr: usize,
    length: usize,
    buf: Vec<u8>,
    small_cache: Vec<u8>,
}

#[allow(dead_code)]
impl Scanner {
    fn new() -> Scanner {
        Scanner {
            ptr: 0,
            length: 0,
            buf: vec![0; 1024],
            small_cache: vec![0; 1024],
        }
    }

    fn load(&mut self) {
        use std::io::Read;
        let mut s = std::io::stdin();
        self.length = s.read(&mut self.buf).unwrap();
    }

    fn byte(&mut self) -> u8 {
        if self.ptr >= self.length {
            self.ptr = 0;
            self.load();
            if self.length == 0 {
                self.buf[0] = b'\n';
                self.length = 1;
            }
        }

        self.ptr += 1;
        return self.buf[self.ptr - 1];
    }

    fn is_space(b: u8) -> bool {
        b == b'\n' || b == b'\r' || b == b'\t' || b == b' '
    }

    fn read_vec<T>(&mut self, n: usize) -> Vec<T>
    where
        T: std::str::FromStr,
        T::Err: std::fmt::Debug,
    {
        (0..n).map(|_| self.read()).collect()
    }

    fn usize_read(&mut self) -> usize {
        self.read()
    }

    fn read<T>(&mut self) -> T
    where
        T: std::str::FromStr,
        T::Err: std::fmt::Debug,
    {
        let mut b = self.byte();
        while Scanner::is_space(b) {
            b = self.byte();
        }

        for pos in 0..self.small_cache.len() {
            self.small_cache[pos] = b;
            b = self.byte();
            if Scanner::is_space(b) {
                return String::from_utf8_lossy(&self.small_cache[0..(pos + 1)])
                    .parse()
                    .unwrap();
            }
        }

        let mut v = self.small_cache.clone();
        while !Scanner::is_space(b) {
            v.push(b);
            b = self.byte();
        }
        return String::from_utf8_lossy(&v).parse().unwrap();
    }
}