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: Runtime Error)

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

                            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.

*******************************************************************************/
signed long* x;
signed long* h;
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);

   }
}




#include <stdio.h>
    signed long n,d,a,i,z,max_count=0,max_index,curr_pos,min,test;
    signed long* count;
    signed long result = 0;
void bomb_1()
    {
       
        for(z=0;z<=d;z++)
        {
            if((curr_pos+z)<n)
                //printf("test:%ld %ld% ld\n",h[curr_pos+z],a,d);
                {
                if(min/a==0)
                  h[curr_pos+z] = h[curr_pos+z] - a;
                else  
                h[curr_pos+z] = h[curr_pos+z] - (a);
                }

            if(h[curr_pos+z]<0)
            {
              h[curr_pos+z] = 0;
            }
        }
        for(z=1;z<=d;z++)
        {
 
            if((curr_pos-z)>=0)
             {  if(min/a==0)
                  h[curr_pos+z] = h[curr_pos+z] - a;
                else  
                h[curr_pos-z] = h[curr_pos-z] - (a);
             }
            if(h[curr_pos-z]<0)
            {
              h[curr_pos-z] = 0;
            }
        }
    }
    
    void count_all()
    {
        max_count = 0;
        min = 0;
        for(i=0;i<n;i++)
    {
        //printf("%ld %ld\n",x[i],h[i]);
        count[i] = 0;
        for(z=0;z<=d;z++)
        {
            if((i+z)<n)
                count[i] = count[i] + h[i+z];

            if(max_count<count[i])
            {
              max_count = count[i];
              max_index = i;
            }
            if((min>h[i+z] && h[i+z] != 0)  || min==0)
            {
             min = h[i+z];
            //printf("min: %ld\n",min);
            }
        }
        for(z=1;z<=d;z++)
        {
 
            if((i-z)>=0)
                count[i] = count [i] + h[i-z];
            if(max_count<count[i])
            {
              max_count = count[i];
              max_index = i;
            }
            if((min>h[i+z] && h[i+z] != 0) || min==0)
            {
             min = h[i+z];
             //printf("min: %ld\n",min);
            }
        }
        
    }
    }
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*) malloc(n * sizeof(signed long));
    for(i=0;i<n;i++)
    {
        scanf("%ld%ld",x+i,h+i);
    }
    //quicksort(x,0,n-1);
    quicksort(x,0,n-1);
    //printf("*************\n");
    count_all();
    
    curr_pos = max_index;
    for(i=0;i<n;i++)
    {
        //printf("%ld %ld %ld\n",x[i],h[i],count[i]);
    }
    //printf("*************\n");
    while(max_count>0)
    {
        
        bomb_1();
        if(min/a==0)
                 result++;
                else 
        result = result + min/a;
        count_all();
        curr_pos = max_index;
      // for(i=0;i<n;i++)
    //{
       // printf("%ld %ld %ld\n",x[i],h[i],count[i]);
   // }
    //printf("*************\n");
        
    }
  
    printf("%ld\n",result);
    return 0;
}