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

#include "bits/stdc++.h"
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <math.h>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair <ll, ll > pll;

bool comp(const pll &a, const pll &b) {
	return a.first < b.first;
}
std::vector<int> enum_div(int n)//nの約数を列挙
{
	std::vector<int> ret;
	for (int i = 1; i*i <= n; ++i)
	{
		if (n%i == 0)
		{
			ret.push_back(i);
			if (i != 1 && i*i != n)
			{
				ret.push_back(n / i);
			}
		}
	}
	return ret;
}


template<int N>
int factorial() {
	return factorial<N - 1>() * N;
}

template<>  /// 特殊化：factorial<N=”1”>だったら，値を返す
int factorial<1>() {
	return 1;
}
int main()
{
	//priority_queue<int> q;
	string s = {};
	string s1 = {};
	ll h = 0, w = 0, k = 0, a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, ans = 0;
	//ll x[300005] = {};
	ll y[300005] = {};
	ll z[302][302] = {};
	cin >> a;
	cin >> b;
	cin >> c;
	//2つの組の数をソートしたりするやつ
	vector<pair<ll, ll> > hoges(a);
	for (int i = 0; i < a; i++)
	{
		cin >> d;
		cin >> e;
		if (e%c == 0)
		{
			e = e / c;
		}
		else
		{
			e = e / c + 1;
		}

		hoges[i] = make_pair(d, e);
	}
	sort(hoges.begin(), hoges.end(), comp);
	//for (int i = 0; i < a; i++)
	//{
	//	cout << hoges[i].first << endl;
	//	cout << hoges[i].second << endl;
	//}
	//cout  << endl;
	queue<pair<ll, ll>> q;
	ll total = 0;
	for (ll i = 0; i < a; i++)
	{
		while (q.size() && q.front().first < hoges[i].first)
		{
			total -= q.front().second;
			q.pop();
		}
		if (hoges[i].second <= total)
		{

		}
		else
		{
			ans += -total + hoges[i].second;
			q.emplace(hoges[i].first + b * 2, -total + hoges[i].second);
			total += -total + hoges[i].second;
		}











		////cout << endl;
		////cout << i << endl;
		////cout << ans<< endl;
		//if (hoges[i].second >= 1)
		//{
		//	


		//	//ans++;
		//	d = i;
		//	/*if (hoges[i].second % c==0)
		//	{
		//	e = hoges[i].second / c;
		//	}
		//	else
		//	{
		//	e = hoges[i].second / c+1;
		//	}*/
		//	g = hoges[i].first;
		//	e = hoges[i].second;
		//	ans += e;
		//	f = 0;
		//	while (d<a&&hoges[d].first <= g + b * 2)
		//	{
		//		hoges[d].second -= e;
		//		if (hoges[d].second <= 0)
		//		{
		//			hoges.erase(hoges.begin() + d);
		//			a--;
		//			d--;
		//			//i--;
		//		}
		//		else
		//		{
		//			f = 1;
		//		}
		//		d++;

		//	}
		//	i--;
		//	//	cout << endl;
		//	//	cout << endl;
		//	//	cout  << endl;
		//	//for (int i = 0; i < a; i++)
		//	//{
		//	//	cout << hoges[i].first << endl;
		//	//	cout << hoges[i].second << endl;
		//	//}
		//}










		//if (hoges[i].second>=1)
		//{
		//	//ans++;
		//	d = i;
		//	/*if (hoges[i].second % c==0)
		//	{
		//		e = hoges[i].second / c;
		//	}
		//	else
		//	{
		//		e = hoges[i].second / c+1;
		//	}*/
		//	e = hoges[i].second;
		//	ans += e;
		//	f = 0;
		//	g = i;
		//	while (d<a&&hoges[d].first<=hoges[i].first+b*2)
		//	{
		//		hoges[d].second -= e;
		//		if (hoges[d].second<=0)
		//		{
		//			if (f==0)
		//			{
		//				//g = max(d, i);
		//				g = d;

		//			}
		//		}
		//		else
		//		{
		//			f = 1;
		//		}
		//		d++;

		//	}
		//	i = g;
		//	//	cout << endl;
		//	//	cout << endl;
		//	//	cout  << endl;
		//	//for (int i = 0; i < a; i++)
		//	//{
		//	//	cout << hoges[i].first << endl;
		//	//	cout << hoges[i].second << endl;
		//	//}
		//}
	}

	cout << ans << endl;



	//return 0;

	/*cout << c << endl;
	cout << b << endl;*/
	//cout << fixed << setprecision(10) <<tmp << endl;
	//cout<<factorial<10><<endl;
	return 0;
}
//2つの組の数をソートしたりするやつ
//vector<pair<ll, ll> > hoges(a);
//for (int i = 1; i <= a; i++)
//{
//	cin >> h;
//	hoges[i - 1] = make_pair(h, i);
//}
//sort(hoges.begin(), hoges.end(), comp);
//for (int i = 0; i < a; i++)
//{
//	cout << hoges[i].second << endl;
//}