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 (GCC 5.4.1) (judge verdict: Time Limit Exceeded)

#include<stdio.h>
#include<stdlib.h>

struct monster{
	int x;
	int hp;
	int range;
};

int partition(struct monster m[], int l, int r){
	int i, j, pivot;
	struct monster t;
	int a, b, i_mid, i_max = l;

	if(m[((l+r)/2)].x > m[i_max].x){
		a = i_max;
		i_max = (l+r)/2;
	}else{
		a = (l+r)/2;
	}

	if(m[r].x > m[i_max].x){
		b = i_max;
		i_max = r;
	}else{
		b = r;
	}

	if(m[a].x > m[b].x){
		i_mid = a;
	}else{
		i_mid = b;
	}

	t = m[i_mid];
	m[i_mid] = m[r];
	m[r] = t;

	i = l-1;
	j = r;
	pivot = m[r].x;

	for(;;){
		while(m[++i].x < pivot){
			;
		}
		while(i < --j && pivot < m[j].x){
			;
		}
		if(i >= j){
			break;
		}
		t = m[i];
		m[i] = m[j];
		m[j] = t;
	}
	t = m[i];
	m[i] = m[r];
	m[r] = t;

	return i;
}

void quick_sort(struct monster m[], int l, int r){
	int v;

	if(l >= r){
		return;
	}

	v = partition(m, l, r);
	quick_sort(m, l, v-1);
	quick_sort(m, v+1, r);
}

unsigned long min_n_attack(struct monster m[], int size, int d, int a){
	int j, k;
	int i_max = size;
	int num_attack_for_i, flag;
	unsigned long n_attack = 0;

	for(;;){
		for(i_max=i_max-1; i_max>=0; i_max--){
			if(m[i_max].hp > 0){
				flag = ((m[i_max].hp)%a == 0) ? 0 : 1;
				num_attack_for_i = (m[i_max].hp)/a + flag;
				break;
			}
		}

		if(i_max < 0){
			break;
		}

		for(j=i_max; j>=0; j--){
			if(m[j].x < m[i_max].range){
				break;
			}
		}

		for(k=i_max; k>=j+1; k--){
			m[k].hp -= num_attack_for_i*a;
		}

		n_attack += num_attack_for_i;
	}

	return n_attack;
}

int main(){
	int n, d, a;
	struct monster *m;
	int i;
	unsigned long result;

	scanf("%d %d %d", &n, &d, &a);
	m = (struct monster *)malloc(sizeof(struct monster)*n);

	for(i=0; i<n; i++){
		scanf("%d %d", &(m[i].x), &(m[i].hp));
		m[i].range = m[i].x - 2*d;
	}
	quick_sort(m, 0, n-1);
	result = min_n_attack(m, n, d, a);

	printf("%lu", result);

	return 0;
}