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++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <utility>
#include <set>
#include <stack>
#include <climits>
#include <cmath>

#define rep(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define rep1(i,n) for(int i=1, i##_len=(n); i<=i##_len; ++i)
#define reps(i,s,n) for(int i=s, i##_len=(n); i<i##_len; ++i)
#define all(x) (x).begin(),(x).end()
#define MEMSET(v, h) memset((v), h, sizeof(v))
typedef long long ll;
const char sp = ' ';


using namespace std;


struct UnionFind{
    vector<ll> par;
    vector<ll> rank;
    vector<ll> sizeth;

    void init(ll N){
        rep(i, N){
            par.push_back(i);
            rank.push_back(0);
            sizeth.push_back(1);
        }
    }

    ll root(ll x) {
        if(par[x]==x) return x;
        else return par[x]=root(par[x]);
    }

    bool isSame(ll x, ll y) {
        return root(x)==root(y);
    }

    bool merge(ll x, ll y) {
        x=root(x);
        y=root(y);
        if(x==y) return false;
        if(rank[x]>rank[y]) swap(x, y);
        sizeth[y] += sizeth[x];
        par[x]=y;
        if(rank[x]==rank[y]) rank[x]++;
        return true;
    }

    ll size(ll x){
        return sizeth[root(x)];
    }
};

int main(void){
    UnionFind unifi;
    ll N, M;
    cin>>N>>M;
    unifi.init(N);
    rep(i, M){
        ll a, b;
        cin>>a>>b;
        unifi.merge(a, b);
    }
    ll Maxima=0;
    rep(i, N){
        Maxima=max(Maxima, unifi.size(i)-1);
    }
    cout<<Maxima<<endl;
    return 0;
}