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 Ruby (2.3.3) (judge verdict: Time Limit Exceeded)

node_num, edge_num = gets.split.map {|i| i.to_i}

class Edge
    attr_reader :left, :right, :index
    def initialize(from, to, index)
        @index = index
        if from < to
            @left = from
            @right = to
        else
            @left = to
            @right = from
        end
    end

end


def finished?(fallen_pos, left_edges)
    # p left_edges
    # puts "----#{fallen_pos}"
    # p left_edges.find{|i| i >= fallen_pos}
    # left_edges.find {|i| i >= fallen_pos }.nil?
    left_edges.sort[-1] < fallen_pos
end

edges = []
lefts = []
# rights = []

edge_num.times do |i|
    from, to = gets.split.map {|i| i.to_i - 1}
    edge = Edge.new(from, to, i)
    edges << edge
    lefts << edge.left
    # rights << edge.right
end

edges.sort_by! {|e| e.left}
rest_edges = edges
last_fallen_edge = 0
fallen_num = 0

while ! finished?(last_fallen_edge, lefts)
    fallen_num += 1
    # puts [rest_edges.size, rest_edges.find_index {|e| e.left >= last_fallen_edge}].join("-")
    # rest_edges.each {|i| puts "#{i.left} -> #{i.right}"}    
    # puts "fallen #{last_fallen_edge} --- #{rest_edges.find_index {|e| e.left >= last_fallen_edge} }"
    # rest_edges = rest_edges[rest_edges.find_index {|e| e.left >= last_fallen_edge} ... -1]

    rest_edges = rest_edges.find_all {|e| e.left >= last_fallen_edge}
    # puts rest_edges.size
    last_fallen_edge = rest_edges.sort_by {|e| e.right }[0].right
    # puts last_fallen_edge
end

puts fallen_num