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 Java8 (OpenJDK 1.8.0) (judge verdict: Time Limit Exceeded)

import java.math.BigDecimal;
import java.math.MathContext;
import java.util.*;

public class Main {

    static int min = Integer.MAX_VALUE;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int a[] = new int[m];
        int b[] = new int[m];
        ArrayList<F> fs = new ArrayList<>();
        ArrayList<F> connects[] = new ArrayList[m];
        for (int i = 0;i < n - 1;++i){
            fs.add(new F());
        }
        for (int i = 0;i < m;++i){
            connects[i] = new ArrayList<>();
            a[i] = sc.nextInt() - 1;
            b[i] = sc.nextInt() - 2;
            for (int j = a[i];j <= b[i];++j){
                fs.get(j).connects.put(i,true);
                connects[i].add(fs.get(j));
            }
        }
        for (int i = 0;i < n - 1;++i){
            fs.get(i).sync();
        }
        fs.sort((c,d) -> {return d.size - c.size;});
        int co = 0;
        while (fs.get(0).connects.size() > 0){
            F f = fs.get(0);
            for (int j:f.connects.keySet()){
                if(!f.connects.get(j))continue;
                for (F fk:connects[j]){
                    if(fk.connects.size() > 0&&fk.connects.containsKey(j)&&fk.connects.get(j)){
                        fk.connects.put(j,false);
                        --fk.size;
                    }
                }
            }
            ++co;
            f.connects.clear();
            f.size = 0;
            fs.sort((c,d) -> {return d.size - c.size;});
        }

        System.out.println(co);
    }



    static class F{
        HashMap<Integer,Boolean> connects = new HashMap<>();
        int size = 0;
        public void sync(){
            size = connects.size();
        }
    }
}