Problem:
Score : 400 points

Problem Statement

There are N one-off jobs available. If you take the i-th job and complete it, you will earn the reward of B_i after A_i days from the day you do it.

You can take and complete at most one of these jobs in a day.

However, you cannot retake a job that you have already done.

Find the maximum total reward that you can earn no later than M days from today.

You can already start working today.

Constraints

All values in input are integers.

1 \leq N \leq 10^5

1 \leq M \leq 10^5

1 \leq A_i \leq 10^5

1 \leq B_i \leq 10^4

Input

Input is given from Standard Input in the following format:

N M
A_1 B_1
A_2 B_2
\vdots
A_N B_N

Output

Print the maximum total reward that you can earn no later than M days from today.

Sample Input 1

3 4
4 3
4 1
2 2

Sample Output 1

5

You can earn the total reward of 5 by taking the jobs as follows:

Take and complete the first job today. You will earn the reward of 3 after four days from today.

Take and complete the third job tomorrow. You will earn the reward of 2 after two days from tomorrow, that is, after three days from today.

Sample Input 2

5 3
1 2
1 3
1 4
2 1
2 3

Sample Output 2

10

Sample Input 3

1 1
2 1

Sample Output 3

0

Solution in C (GCC 5.4.1) (judge verdict: Wrong Answer)

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

struct node{
	int value;
	int cost;
	int done;
};

void swap(struct node *a, struct node *b)
{
	struct node tmp = *a;
	*a = *b;
	*b = tmp;
}

void heapify(struct node *arry, int start, int end)
{
	int parent = start;
	int child = parent * 2 + 1;

	while (child < end)
	{
		if ((arry[child].cost < arry[child + 1].cost) && (child < end))
			child++;

		if (arry[child].cost <= arry[parent].cost)
			break;
		else
		{
			swap(&arry[child], &arry[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
	}
}

void heapSort(struct node *arry, int start, int end)
{
	int mid = (start + end) / 2;
	int i = mid;

	for (i; i >= start; i--)
		heapify(arry, i, end);

	for (i = end; i >= start; i--)
	{
		swap(&arry[start], &arry[i]);
		heapify(arry, start, i - 1);
	}
}

int main()
{
	struct node *arry = NULL;
	int n, m;
	int i;
	int cost = 0;
	int result = 0;

	if(scanf("%d %d", &n, &m));

	arry = malloc(sizeof(struct node) * n);
	if (arry == NULL)
	{
		printf("Failed to allocate memory %d\n", errno);
		return -1;
	}

	for (i = 0; i < n; i++)
	{
		if(scanf("%d %d", &arry[i].value, &arry[i].cost));
		arry[i].done = 0;
	}

	heapSort(arry, 0, n - 1);

	i = 0;
	printf("-----\n");
	while (i < n )
	{
		if ((arry[i].done != 1) && (arry[i].cost + cost) < m)
		{
			printf("val:cost %d %d\n", arry[i].value, arry[i].cost);
			printf("sum val:cost %d %d\n", result, cost);
			result += arry[i].value;
			cost += arry[i].cost;
			arry[i].done = 1;
		}
		i++;
	}

	printf("%d\n", result);

	return 0;
}