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: Accepted)

fn main() {
    let (r, w) = (std::io::stdin(), std::io::stdout());
    let mut sc = IO::new(r.lock(), w.lock());
    let n: usize = sc.read();
    let x: Vec<u64> = sc.vec(n);
    let l: u64 = sc.read();

    let x_max = x[n - 1];
    let mut inv_x = x.iter().map(|&x| x_max - x).collect::<Vec<_>>();
    inv_x.reverse();

    let q: usize = sc.read();
    let map = calc_map(x, l);
    let inv_map = calc_map(inv_x, l);
    for _ in 0..q {
        let a: usize = sc.read();
        let b: usize = sc.read();
        if a < b {
            let (a, b) = (a - 1, b - 1);

            let mut ok = 1 << 60;
            let mut ng = 0;
            while ok - ng > 1 {
                let cost = (ok + ng) / 2;
                if can_go(&map, a, b, cost) {
                    ok = cost;
                } else {
                    ng = cost;
                }
            }
            sc.write(format!("{}\n", ok));
        } else {
            let (a, b) = (n - a, n - b);

            let mut ok = 1 << 60;
            let mut ng = 0;
            while ok - ng > 1 {
                let cost = (ok + ng) / 2;
                if can_go(&inv_map, a, b, cost) {
                    ok = cost;
                } else {
                    ng = cost;
                }
            }
            sc.write(format!("{}\n", ok));
        }
    }
}

fn can_go(map: &Vec<Vec<usize>>, a: usize, b: usize, cost: u64) -> bool {
    let mut cur = a;
    for i in 0..60 {
        if (1 << i) & cost != 0 {
            cur = map[i][cur] - 1;
        }
    }
    cur >= b
}

fn calc_map(x: Vec<u64>, l: u64) -> Vec<Vec<usize>> {
    let n = x.len();
    let mut upper = vec![0; n];
    let mut tail = 0;
    for from in 0..n {
        if tail < from {
            tail = from;
        }
        while tail < n && x[tail] - x[from] <= l {
            tail += 1;
        }
        upper[from] = tail;
    }

    let mut map = vec![upper];
    for i in 0..60 {
        let mut upper = vec![0; n];
        for from in 0..n {
            let hop = map[i][from] - 1;
            upper[from] = map[i][hop];
        }
        map.push(upper);
    }
    map
}

pub struct IO<R, W: std::io::Write>(R, std::io::BufWriter<W>);

impl<R: std::io::Read, W: std::io::Write> IO<R, W> {
    pub fn new(r: R, w: W) -> IO<R, W> {
        IO(r, std::io::BufWriter::new(w))
    }
    pub fn write<S: std::ops::Deref<Target = str>>(&mut self, s: S) {
        use std::io::Write;
        self.1.write(s.as_bytes()).unwrap();
    }
    pub fn read<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let buf = self
            .0
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t')
            .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t')
            .collect::<Vec<_>>();
        unsafe { std::str::from_utf8_unchecked(&buf) }
            .parse()
            .ok()
            .expect("Parse error.")
    }
    pub fn vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read()).collect()
    }
    pub fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}