区间选点

题目要求

数轴上有 n 个闭区间 [a_i, b_i]。取尽量少的点，使得每个区间内都至少有一个点（不同区间内含的点可以是同一个）

Input
第一行1个整数N（N<=100）
第2~N+1行，每行两个整数a,b（a,b<=100）

Output
一个整数，代表选点的数目

Examples
Input 
2
1 5
4 6
Output 
1
Input 
3
1 3
2 5
4 6
Output 
2

思路

这个题目真的很绕，第一个问题是选哪个点，为了尽量取最少的点，并且选点过程是在数轴上从小到大，我们的选择应该是一个区间的右端点。
第二个问题就是按照什么排列给定的区间，这个问题很重要。
有两种方法，一个是优先按照区间左端点排列，左端点相同的区间，按照右端点排列。这个方法看起来很常规，但是仔细推敲会发现这个方法不合适，比如说
如果按照这个方法排列的话，区间a在数组的位置应该在区间b的前面，就会优先选择区间a的右端点，那么就会导致区间b中不包含任何点。

另一个方法是优先按照区间右端点排列，右端点相同的区间，按照左端点排列。
这种方法排列下区间b在数组的位置在区间a的前面,那么优先选择区间b的右端点，由于选点过程是在数轴上从小到大，所以b区间不会丢失。然后我们就可以 sort 排序啦~

那么问题它又来了，b区间不丢了，a会不会丢呢，此时，我们已知b的右端点在a的右端点之前，那么就有两种情况：

1. a的左端点在b的右端点之前或就是b的右端点
   
2. a的左端点在b的右端点之后
   
   对于1，显然b的右端点一定在a区间中
   对于2，这就是程序循环的关键了，这种情况下a与b已经是两个选点范围中的区间了。也就是说，我们该以a区间右端点条件，去找下一个右端点在a的右端点右侧，但左端点在a的右端点左侧的区间啦。

那么这样做会不会漏掉一些区间呢？
现在我们来看看可能出现的区间c，

1.
2.
3.
4.
对于1，显然b的右端点在c区间中
对于2，因为选点过程是在数轴上从小到大，所以这种情况下c应该替代掉a被优先选出来
对于3，这种情况下a的右端点在c区间中
对于4，这时，c的左端点在a的右端点右侧，这时重复上述过程，以c的右端点为条件。
综上，区间c是不会被漏掉的，同时，选出的点的个数应该是最少的。

另外，每一次循环的起点是选中的上一个点x，需要对左端点在x右侧的区间进行判断，此次循环选出的点是左端点在x右侧的第一个区间的右端点y，因此，设置全局变量b来记录下一次循环中的y所在的区间会方便很多。

furthermore，如果不想这么麻烦，还可以先把所有包含小区间的大区间去掉或改成小区间，也就是说，下面这种情况可以把a去掉，这样上述分析会简单很多。

去掉大区间的代码我放在最后啦~（但其实我没用到

代码

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
struct point
{
	int begin;
	int end;
	bool operator<(const point& b)
	{
		if (end!= b.end)return end < b.end;
		return begin < b.begin;
	}
};
int num = 0;
int b, e;
int find(point* a, int size, int _s)
{
	int max = _s;
	int site = -1;
	for (int i = b; i < size; i++)
	{
		if (a[i].begin <= _s && a[i].end >= max)
		{
			max = a[i].end;
			//		cout << max;
			site = i;
		}
		if (a[i].begin > _s)
		{
			b = i;
			break;
		}
	}
	return site;
}
int main()
{
	int N;
	cin >> N;
	
	point* arr = new point[N];
	int max = 0;
	for (int i = 0; i < N; i++)
	{
		cin >> arr[i].begin >> arr[i].end;
		if (arr[i].end > max)
			max = arr[i].end;
	}
	if (N == 0) { cout << 0; return 0; }
	if (N == 1) { cout << 1; return 0; }
	sort(arr, arr + N);
//	erasesame(arr,N);
//	sort(arr, arr + N);
	b = 0;
	int s = arr[0].end;
	while (1)
	{
		num++;
		int con;
		con = find(arr, N, s);
		s = arr[b].end;
		if (arr[con].end == max)
		{
			cout << num;
			break;
		}
		
	}

}

上面的代码是有缺陷的，缺陷是：每轮后用该轮最大值是否等于所有区间最大值来确定是否结束，但如果有一个区间右端点 小于 所有区间的最大值，并且没有被包含在上一轮中，而上一轮的最大值是所有区间的最大值（直接退出）这样这个区间就被遗漏了。可以添加一个变量对遍历过的区间记录，当所有区间都被遍历过了再退出，一个正确的写法是下边这个：

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
struct point
{
	int begin;
	int end;
	bool operator<(const point& b)
	{
		if (end != b.end)
			return end < b.end;
		return begin < b.begin;
	}
};
int points = 1;
int num = 0;
int b, e;
int find(point* a, int size, int _s)
{
	int site = _s;
	for (int i = 0; i < size; i++)
	{
		if (a[i].begin <= site && a[i].end >= site)
		{
			continue;
		}
		if (a[i].begin > site)
		{
			site = a[i].end;
			points++;
		}
	}
	return points;
}

int main()
{
	int N;
	cin >> N;
	//point arr[111];
	point* arr = new point[N];
	int max = -1;
	for (int i = 0; i < N; i++)
	{
		cin >> arr[i].begin >> arr[i].end;
		if (arr[i].end > max)
			max = arr[i].end;
	}
	if (N == 0) { cout << 0; return 0; }
	if (N == 1) { cout << 1; return 0; }
	sort(arr, arr + N);
	b = 0;
	int s = arr[0].end;
	cout<<find(arr, N, s);

	return 0;
}

void erasesame(point* a, int size)
{
	for (int i = 0; i < size; i++)
	{
		for (int j = i; j < size; j++)
		{
			if (a[j].begin > a[i].end)
				break;
			if (a[i].begin <= a[j].begin && a[i].end >= a[j].end)
			{
				a[i].begin = a[j].begin; a[i].end = a[j].end;
			}
		}
	}
}