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)

/******************************************************************************

                            Online C Compiler.
                Code, Compile, Run and Debug C program online.
Write your code in this editor and press "Run" button to compile and execute it.

*******************************************************************************/
#include <stdio.h>
signed long n,d,a;
long long test = 0;
signed  long* x;
signed  long* h;
signed long long* count;
signed long* min;
signed long long max_count = -1;
signed long curr_pos = 0;
signed long max_index;
signed long number_of_bombs = 0;
signed long long result = 0;
void quicksort(signed long number[],signed  long first,signed long last){
   signed long i, j, pivot, temp;

   if(first<last){
      pivot=first;
      i=first;
      j=last;

      while(i<j){
         while(number[i]<=number[pivot]&&i<last)
            i++;
         while(number[j]>number[pivot])
            j--;
         if(i<j){
            temp = h[i];
            h[i]=h[j];
            h[j]=h[i]; 
            temp=number[i];
            number[i]=number[j];
            number[j]=temp;
            
         }
      }
      temp=h[pivot];
      h[pivot]=h[j];
      h[j]=temp;
      temp=number[pivot];
      number[pivot]=number[j];
      number[j]=temp;
      quicksort(number,first,j-1);
      quicksort(number,j+1,last);

   }
}





signed long bomb(void)
{
    signed long i;
    if(min[curr_pos]<=a)
     number_of_bombs = 1;
    else
     number_of_bombs = min[curr_pos]/a;
   // printf("min is: %ld\n",min[curr_pos]);
   // printf("number_of_bombs is: %ld\n",number_of_bombs);
    for(i=0;i<=d;i++)
    {
       // printf("decreasing\n");
        if((i+curr_pos)<n)
        {
          //printf("At pos: %ld health was: %ld\n",curr_pos+1+i,h[curr_pos+i]);
          h[curr_pos+i] = h[curr_pos+i] - number_of_bombs*a;
          if(h[curr_pos+i] < 0)
            h[curr_pos+i] = 0;
          //printf("At pos: %ld health is: %ld\n",curr_pos+1+i,h[curr_pos+i]);
        }
        if((curr_pos-i)>=0 && i!=0)  
        {
         //  printf("At pos: %ld health was: %ld\n",curr_pos+1-i,h[curr_pos-i]);
           h[curr_pos-i] = h[curr_pos-i] - number_of_bombs*a;
           if(h[curr_pos-i] < 0)
            h[curr_pos-i] = 0;
          // printf("At pos: %ld health is: %ld\n",curr_pos+1-i,h[curr_pos-i]);
        }
        
      //  printf("decreasing done\n") ;
          
    }
    //h[curr_pos] = h[curr_pos] + number_of_bombs*a;
   // printf("At pos: %ld health is: %ld\n",curr_pos+1,h[curr_pos]);
    return number_of_bombs;
}
    
void count_all_nodes(void)
{
    signed long i,j;
    max_count = 0;
    for(i=0;i<n;i++)
    {
        count[i] = 0;
        min[i] = -1;
        for(j=0;(j<=d);j++)
        {
            if((i+j)<n)
             count[i] = count[i] + h[i+j];
            
            if((i-j)>=0)
             count[i] = count[i] + h[i-j];
             
            if((i+j)<n) 
                if(((h[i+j]<= min[i]) || (min[i] == -1)) && h[i+j]!=0)
                    min[i] = h[i+j];
            if((i-j)>=0) 
                if(((h[i-j]<= min[i]) || (min[i] == -1)) && h[i-j]!=0)
                    min[i] = h[i-j]; 
        }
        count[i] = count[i] - h[i];
        if(max_count < count[i])
        {
            max_count = count[i];
            max_index = i;
        }
    }
    curr_pos = max_index;
    //printf("curr_pos: %ld\n",curr_pos+1);
}
int main()
{

    scanf("%ld%ld%ld",&n,&d,&a);
    x = (signed long*) malloc(n * sizeof(signed  long));
    h = (signed  long*) malloc(n * sizeof(signed long));
    count = (signed long long*) malloc(n * sizeof(signed long long));
    min = (signed long*) malloc(n * sizeof(signed long));
    signed long i;
    for(i=0;i<n;i++)
    {
        scanf("%ld%ld",x+i,h+i);
    }

    quicksort(x,0,n-1);
   // printf("*************\n");
    count_all_nodes();
    
    //for(i=0;i<n;i++)
    {
     //   printf("%ld %ld %lld %ld\n",x[i],h[i],count[i],min[i]);
    }
   // printf("*************\n");
    while(max_count>0)
    {
      //  printf("bombing\n");
        result = result + bomb();
        count_all_nodes();
        test++;
        if(test>5000)
      //  for(i=0;i<n;i++)
        {
       //     printf("%ld %ld %lld %ld\n",x[i],h[i],count[i],min[i]);
       
       break;
        }
       // printf("max_count is: %lld , max_pos is: %ld\n",max_count,max_index+1);
    }
  
    printf("%lld\n",result);
    return 0;
}