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 C (GCC 5.4.1) (judge verdict: Accepted)

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h> // uint64_t

#define max(a,b) ((a) > (b) ? (a) : (b))
#define min(a,b) ((a) > (b) ? (b) : (a))
#define VERTEX_MAX 100000
#define BUF_SIZE 20

int get_int2(int *a1, int *a2) {
#ifdef BUF_SIZE
  char line[BUF_SIZE];
  if(!fgets(line, BUF_SIZE, stdin)) return -1;
  sscanf(line, "%d %d", a1, a2);
#else
#error
#endif
  return 0;
}

struct range {
    int start;
    int end;
};

int asc_by_start(const void *a1, const void *a2) {
    struct range *ra1 = (struct range*)a1;
    struct range *ra2 = (struct range*)a2;
    return ra1->start - ra2->start;
}

int main(void) {
    int vs, queries;
    get_int2(&vs, &queries);
    struct range ranges[VERTEX_MAX+1];
    int i;
    for(i = 0; i < queries; i++) {
        int s, e;
        get_int2(&s, &e);
        // 1-indexed -> 0-indexed
        s--; e--;
        ranges[i] = (struct range){s, e};
    }
    ranges[queries] = (struct range){VERTEX_MAX+1, VERTEX_MAX+2};
    qsort(ranges, queries, sizeof(struct range), asc_by_start);
    int cnt = 0;
    struct range prev = ranges[0];
    for(i = 1; i < queries+1; i++) {
        struct range cur = ranges[i];
        if(prev.end - 1 >= cur.start) {
            prev.end = min(prev.end, cur.end);
            continue;
        }
#ifdef DEBUG
        printf("cur: [%d, %d], prev: [%d %d]\n",
            cur.start, cur.end,
            prev.start, prev.end
        );
#endif
        cnt++;
        prev = cur;
    }
    printf("%d\n", cnt);
    return 0;
}