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 Rust (1.15.1) (judge verdict: Accepted)


#[derive(Debug)]
struct UnionFindBitset { bitset: Vec<usize> }
impl UnionFindBitset {
  fn new(size: usize) -> UnionFindBitset {
    let mut bitset = (0 .. size).collect::<Vec<usize>>();
    UnionFindBitset{ bitset: bitset }
  }
  
  fn next_clear_bit(&mut self, base : usize) -> Option<usize> {
    if base >= self.bitset.len() { 
      None 
    } else if base == self.bitset[base] { 
      Some(base) 
    } else {
      let t = self.bitset[base];
      let r = self.next_clear_bit(t);
      self.bitset[base] = r.unwrap_or(self.bitset.len());
      r
    }
  }
  
  fn extend_bits(&mut self, base : usize) ->  Option<usize> {
    let r = self.next_clear_bit(base);
    if r.is_none() { return r; }
    let i = r.unwrap();
    let j = self.next_clear_bit(i + 1).unwrap_or(self.bitset.len());
    self.bitset[i] = j;
    r
  }
}

fn main(){
  let mut stdin = String::new();
  std::io::Read::read_to_string(
      &mut std::io::stdin(),
      &mut stdin).unwrap();
  let mut stdin = stdin.split_whitespace();
  let mut get = || stdin.next().unwrap();
  
  macro_rules! get {
      () => {
        (get().parse::<usize>().unwrap(), get().parse::<usize>().unwrap())
      };
  }

  let (n, m) = get!();

  let mut bitset = UnionFindBitset::new(m + 1);
  let mut jobs = Vec::with_capacity(n);
  
  for i in 0 .. n {
    jobs.push(get!());  
  }
  jobs.sort_by_key(|x| x.1 );
  jobs.reverse();
  let mut ans = 0;
  
  for j in jobs.into_iter() {
    if let Some(_) = bitset.extend_bits(j.0) {
      ans += j.1;
    }
  }
  
  print!("{}", ans)
}