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: Accepted)

package main

import (
	"bufio"
	"os"
	"strconv"
	"sort"
	"fmt"
)

var sc = bufio.NewScanner(os.Stdin)

func nextString() string {
	if !sc.Scan() {
		panic("failed scan string")
	}
	return sc.Text()
}

func nextInt() int {
	if !sc.Scan() {
		panic("failed scan int")
	}
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

type pair struct {
	start int
	end   int
}

func main() {
	sc.Split(bufio.ScanWords)

	// start -> id map
	startMap := make(map[int]map[int]struct{})
	// end -> id map
	endMap := make(map[int]map[int]struct{})
	idMap := make(map[int]pair)

	_ = nextInt()
	m := nextInt()

	for i := 0; i < m; i ++ {
		start := nextInt()
		end := nextInt() - 1
		if _, ok := startMap[start]; ok {
			startMap[start][i] = struct{}{}
		} else {
			startMap[start] = map[int]struct{}{i: {}}
		}

		if _, ok := endMap[end]; ok {
			endMap[end][i] = struct{}{}
		} else {
			endMap[end] = map[int]struct{}{i: {}}
		}

		idMap[i] = pair{start: start, end: end}
	}

	startList := make([]int, len(startMap))
	var i int
	for start, _ := range startMap {
		startList[i] = start
		i++
	}
	sort.Ints(startList)

	endList := make([]int, len(endMap))
	i = 0
	for end, _ := range endMap {
		endList[i] = end
		i++
	}
	sort.Ints(endList)

	var count int
	var currentEnd int
	for _, start := range startList {
		if start <= currentEnd {
			ids := startMap[start]
			for id, _ := range ids {
				delete(idMap, id)
			}
			continue
		}

		var found bool
	endloop:
		for ; len(endList) > 0; {
			end := endList[0]
			endList = endList[1:]
			ids := endMap[end]
			for id, _ := range ids {
				if _, ok := idMap[id]; ok {
					found = true
					currentEnd = end
					break endloop
				}
			}
		}
		if !found {
			break
		}

		ids := startMap[start]
		for id, _ := range ids {
			delete(idMap, id)
		}
		count++
	}

	fmt.Println(count)
}