Problem:
Score : 600 points

Problem Statement

Silver Fox is fighting with N monsters.

The monsters are standing in a row, and we can assume them to be standing on a number line. The i-th monster, standing at the coordinate X_i, has the health of H_i.

Silver Fox can use bombs to attack the monsters.
Using a bomb at the coordinate x decreases the healths of all monsters between the coordinates x-D and x+D (inclusive) by A.
There is no way other than bombs to decrease the monster's health.

Silver Fox wins when all the monsters' healths become 0 or below.

Find the minimum number of bombs needed to win.

Constraints

1 \leq N \leq 2 \times 10^5

0 \leq D \leq 10^9

1 \leq A \leq 10^9

0 \leq X_i \leq 10^9

1 \leq H_i \leq 10^9

X_i are distinct.

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N D A
X_1 H_1
:
X_N H_N

Output

Print the minimum number of bombs needed to win.

Sample Input 1

3 3 2
1 2
5 4
9 2

Sample Output 1

2

First, let us use a bomb at the coordinate 4 to decrease the first and second monsters' health by 2.

Then, use a bomb at the coordinate 6 to decrease the second and third monsters' health by 2.

Now, all the monsters' healths are 0.
We cannot make all the monsters' health drop to 0 or below with just one bomb.

Sample Input 2

9 4 1
1 5
2 4
3 3
4 2
5 1
6 2
7 3
8 4
9 5

Sample Output 2

5

We should use five bombs at the coordinate 5.

Sample Input 3

3 0 1
300000000 1000000000
100000000 1000000000
200000000 1000000000

Sample Output 3

3000000000

Watch out for overflow.

Solution in Rust (1.15.1) (judge verdict: Accepted)

#[derive(Debug)]
struct Monster {
    x: i64,
    h: i64,
}

fn main() {
    let (n, d, a) = read_tuple();
    let (d, a) = (d as i64, a as i64);
    let mut monsters: Vec<Monster> = (0..n).map(|_| {
        let tmp = read_vec();
        Monster { x: tmp[0], h: tmp[1] }
    }).collect();

    monsters.sort_by_key(|m| m.x);

    let mut effect = vec![0; n + 1];
    let mut ans = 0;
    let mut damage = 0;
    for i in 0..n {
        damage -= effect[i] * a;
        monsters[i].h -= damage;
        let Monster { x: xi, h: hi } = monsters[i];

        if hi > 0 {
            let attack_times = hi / a + if hi % a != 0 { 1 } else { 0 };
            ans += attack_times;
            damage += attack_times * a;

            let range = xi + 2 * d;
            let (mut l, mut h) = (0, n);
            while l < h - 1 {
                let m = (l + h) / 2;
                if monsters[m].x > range {
                    h = m;
                } else {
                    l = m;
                }
            }
            if l < n {
                effect[l + 1] += attack_times;
            }
        }
    }

    println!("{:?}", ans);
}
fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().split_whitespace()
        .map(|e| e.parse().ok().unwrap()).collect()
}
fn read_tuple<T: std::str::FromStr + Copy>() -> (T, T, T) {
    let temp = read_vec();
    (temp[0], temp[1], temp[2])
}