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 C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <iostream>
#include <map>
#include <vector>
#include <assert.h>
#include <algorithm>

using namespace std;
using I=long long int;using II=pair<I, I>;
const I NMAX = 2 * 100000 + 10, INF = 10000000000, ROOT = 1;
// [x-D, x+D] damage A
I N, D, A;
struct M {I h;I x;M(I h, I x) : h(h), x(x) {};M() : x(INF), h(0) {};};

vector<M> ms;
vector<II> endix2dmg;

int main() {
#ifdef LOCAL
    freopen("/home/bollu/temp/f.in3", "r", stdin);
#endif
    cin.tie(NULL);ios::sync_with_stdio(false);
    cin >> N >> D >> A;
    for (I i = 0; i < N; ++i) {
        M m;cin >> m.x >> m.h;ms.push_back(m);
    }
    sort(ms.begin(), ms.end(), [](M a, M b) { return a.x < b.x; });

    I totbomb = 0, totdmg = 0;
    for (M m : ms) {
        while (endix2dmg.size() && endix2dmg[0].first < m.x) {
            totdmg -= endix2dmg[0].second;
            std::pop_heap(endix2dmg.begin(), endix2dmg.end());
            endix2dmg.resize(endix2dmg.size() -1);
        }
        const I nbomb = max<I>((m.h - totdmg + A - 1) / A, 0), dmg = nbomb * A;
        if (nbomb == 0) continue;

        totbomb += nbomb;
        totdmg += dmg;
        endix2dmg.push_back({m.x + 2 * D, dmg});
        std::push_heap(endix2dmg.begin(), endix2dmg.end(),
                [](II a, II b) { return a.first < b.first; });
    }
    cout << totbomb; //<< flush;
    return 0;
}