Problem:
Score : 400 points

Problem Statement

There are N islands lining up from west to east, connected by N-1 bridges.

The i-th bridge connects the i-th island from the west and the (i+1)-th island from the west.

One day, disputes took place between some islands, and there were M requests from the inhabitants of the islands:

Request i: A dispute took place between the a_i-th island from the west and the b_i-th island from the west. Please make traveling between these islands with bridges impossible.

You decided to remove some bridges to meet all these M requests.

Find the minimum number of bridges that must be removed.

Constraints

All values in input are integers.

2 \leq N \leq 10^5

1 \leq M \leq 10^5

1 \leq a_i < b_i \leq N

All pairs (a_i, b_i) are distinct.

Input

Input is given from Standard Input in the following format:

N M
a_1 b_1
a_2 b_2
:
a_M b_M

Output

Print the minimum number of bridges that must be removed.

Sample Input 1

5 2
1 4
2 5

Sample Output 1

1

The requests can be met by removing the bridge connecting the second and third islands from the west.

Sample Input 2

9 5
1 8
2 7
3 5
4 6
7 9

Sample Output 2

2

Sample Input 3

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

Sample Output 3

4

Solution in Rust (1.15.1) (judge verdict: Accepted)

#[allow(unused_imports)]
use std::cmp::{min,max};
#[allow(unused_imports)]
use std::collections::BTreeMap;
#[allow(unused_imports)]
use std::ops::*;
#[allow(unused_imports)]
use std::collections::BinaryHeap;

struct DoubleBinaryHeap<T,U> {
    first:      BinaryHeap<(T,U)>,
    first_del:  BinaryHeap<(T,U)>,
    second:     BinaryHeap<(U,T)>,
    second_del: BinaryHeap<(U,T)>,
}

impl<T:Ord+Copy,U:Ord+Copy> DoubleBinaryHeap<T,U> {
    fn new() -> DoubleBinaryHeap<T,U> {
        DoubleBinaryHeap {
            first: BinaryHeap::new(),
            first_del: BinaryHeap::new(),
            second: BinaryHeap::new(),
            second_del: BinaryHeap::new(),
        }
    }
    fn push(&mut self, x: T, y: U) {
        self.first.push((x,y));
        self.second.push((y,x));
    }
    fn normalize_first(&mut self) {
        while ! self.first.is_empty() && ! self.first_del.is_empty() && self.first.peek().unwrap() == self.first_del.peek().unwrap() {
            self.first.pop();
            self.first_del.pop();
        }
    }
    fn normalize_second(&mut self) {
        while ! self.second.is_empty() && ! self.second_del.is_empty() && self.second.peek().unwrap() == self.second_del.peek().unwrap() {
            self.second.pop();
            self.second_del.pop();
        }
    }
    fn peek_first(&mut self) -> Option<&(T,U)> {
        self.normalize_first();
        self.first.peek()
    }
    fn peek_second(&mut self) -> Option<&(U,T)> {
        self.normalize_second();
        self.second.peek()
    }
    fn pop_first(&mut self) -> Option<(T,U)> {
        self.normalize_first();
        match self.first.pop() {
            Some((a,b)) => {
                self.second_del.push((b,a));
                Some((a,b))
            }
            None => {
                None
            }
        }
    }
    fn pop_second(&mut self) -> Option<(U,T)> {
        self.normalize_second();
        match self.second.pop() {
            Some((b,a)) => {
                self.first_del.push((a,b));
                Some((b,a))
            }
            None => {
                None
            }
        }
    }
}

fn main() {
    let (_,m) = {
        let xs = read_vec_i64();
        (xs[0] as usize, xs[1] as usize)
    };
    let mut dheap = DoubleBinaryHeap::<i64,i64>::new();
    let mut xs = vec![];
    for _ in 0..m {
        let ts = read_vec_i64();
        let (a,b) = (ts[0], ts[1]);
        xs.push((a,b));
        dheap.push(-a,-b);
    }
    let mut res = 0;
    loop {
        if let Some((nb1,_)) = dheap.pop_second() {
            res += 1;
            loop {
                let mut flag = false;
                if let Some(&(na2,_)) = dheap.peek_first() {
                    if -na2 < -nb1 {
                        flag = true;
                    }
                }
                if flag {
                    dheap.pop_first();
                }
                else {
                    break;
                }
            }
        }
        else {
            break;
        }
    }
    println!("{}", res);
}

#[allow(dead_code)]
fn read_line() -> String {
    let mut ret = String::new();
    std::io::stdin().read_line(&mut ret).ok();
    ret.pop();
    return ret;
}

#[allow(dead_code)]
fn read_i64() -> i64 {
    let ss = read_line();
    return ss.parse::<i64>().unwrap();
}

#[allow(dead_code)]
fn read_vec_i64() -> Vec<i64> {
    let mut res = vec![];
    let ss = read_line();
    for ts in ss.split_whitespace() {
        let x = ts.parse::<i64>().unwrap();
        res.push(x);
    }
    return res;
}

use std::fmt::Display;
#[allow(dead_code)]
fn write_vec<T: Display>(xs: &Vec<T>) {
    if xs.len() == 0 {
        println!("");
        return;
    }
    print!("{}", xs[0]);
    for i in 1..xs.len() {
        print!(" {}", xs[i]);
    }
    println!("");
}