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>

struct pair
{
	int key;
	int bi;
};

void quicksort(struct pair data[],int left,int right);

int main()
{
    int n,m,i,j,a,b,flag=0,ans=0;
	struct pair arr[100000];
	int kenarr[100000][2];
	//int ans=0;
	scanf("%d %d",&n,&m);
	for(i=0;i<m;i++)
	{
		scanf("%d %d",&(arr[i].key),&(arr[i].bi));
	}
	quicksort(arr,0,m-1);
	

	for(i=0;i<m;i++)
	{
		if(ans==(n-2))break;
		a=arr[i].key;
		b=arr[i].bi;
		if(i==0)
		{
			kenarr[0][0]=a;
			kenarr[0][1]=b;
		}
		else
		{
			flag=0;
			for(j=0;j<=ans;j++)
			{
				if((kenarr[j][1]>a)&&(kenarr[j][0]<b))
				{
					flag=1;
					if(kenarr[j][0]<a)kenarr[j][0]=a;
					if(kenarr[j][1]>b)kenarr[j][1]=b;
				}
				if(flag)break;
			}
			if(!flag)
			{
				ans++;
				kenarr[ans][0]=a;
				kenarr[ans][1]=b;
			}
		}
	}
	
	//for(i=0;i<ans+1;i++)printf("%d,%d\n",kenarr[i][0],kenarr[i][1]);
	printf("%d",ans+1);
}


void quicksort(struct pair data[],int left,int right)
{
	int i,j;
	struct pair std,work;
	if(left<right)
	{
		i=left,j=right;
		std=data[(i+j)/2];//基準
		do
		{
			while(data[i].key < std.key)i++;
			while(data[j].key > std.key)j--;
			if(i<=j)
			{
				if(i<j)
				{
					work=data[i];
					data[i]=data[j];
					data[j]=work;
				}
				i++; j--;
			}
		}while(i<=j);
		if(left<j)quicksort(data,left,j);
		if(i<right)quicksort(data,i,right);
	}
}