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;

fn main() {
    let (n,m) = {
        let xs = read_vec_i64();
        (xs[0] as usize, xs[1] as usize)
    };
    let mut first: BinaryHeap<(i64,usize)> = BinaryHeap::new();
    let mut first_del: BinaryHeap<(i64,usize)> = BinaryHeap::new();
    let mut second: BinaryHeap<(i64,usize)> = BinaryHeap::new();
    let mut second_del: BinaryHeap<(i64,usize)> = BinaryHeap::new();
    let mut xs = vec![];
    for i in 0..m {
        let ts = read_vec_i64();
        let (a,b) = (ts[0] - 1, ts[1] - 1);
        xs.push((a,b));
        first.push((-a,i));
        second.push((-b,i));
    }
    let mut res = 0;
    loop {
        //eprintln!("aa");
        while ! second.is_empty() && !second_del.is_empty() && second.peek().unwrap() == second_del.peek().unwrap() {
            second.pop();
            second_del.pop();
        }
        if second.is_empty() {
            break;
        }
        let (b,i) = second.pop().unwrap();
        first_del.push((-xs[i].0,i));
        res += 1;
        loop {
            //eprintln!("bb");
            while ! first.is_empty() && ! first_del.is_empty() && first.peek().unwrap() == first_del.peek().unwrap() {
                first.pop();
                first_del.pop();
            }
            if first.is_empty() {
                break;
            }
            if -first.peek().unwrap().0 < -b {
                let (a,k) = first.pop().unwrap();
                second_del.push((-xs[k].1,k));
            }
            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!("");
}