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 Go (1.6) (judge verdict: Wrong Answer)

package main

import (
	"fmt"
	"sort"
)

type Asbs struct {
	as []int
	bs []int
}

func (asbs Asbs) Len() int {
	return len(asbs.as)
}

func (asbs Asbs) Swap(i, j int) {
	asbs.as[i], asbs.as[j] = asbs.as[j], asbs.as[i]
	asbs.bs[i], asbs.bs[j] = asbs.bs[j], asbs.bs[i]
}

func (asbs Asbs) Less(i, j int) bool {
	return asbs.bs[i]-asbs.as[i] > asbs.bs[j]-asbs.as[j]
}

func main() {
	var N, M int
	fmt.Scanf("%d%d", &N, &M)
	as := make([]int, 0)
	bs := make([]int, 0)
	for i := 0; i < M; i++ {
		var ai, bi int
		fmt.Scanf("%d%d", &ai, &bi)
		for j := 0; j < len(as); j++ {
			//fmt.Printf("%d %d\n", as[j], bs[j])
			if as[j] < bi && ai < bs[j] {
				if as[j] < ai {
					as[j] = ai
				}
				if bi < bs[j] {
					bs[j] = bi
				}
				goto BREAK
			}
		}
		as = append(as, ai)
		bs = append(bs, bi)
		sort.Sort(Asbs{as: as, bs: bs})
	BREAK:
	}
	fmt.Printf("%d\n", len(as))
}