洛谷线性动态规划训练（1）与二分查找训练：P1020 导弹拦截

P1020 导弹拦截

题目描述
某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭。由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。

输入导弹依次飞来的高度（雷达给出的高度数据是\le 50000≤50000的正整数），计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。

输入格式
11行，若干个整数（个数\le 100000≤100000）

输出格式
22行，每行一个整数，第一个数字表示这套系统最多能拦截多少导弹，第二个数字表示如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。

输入输出样例
输入 #1复制
389 207 155 300 299 170 158 65
输出 #1复制
6
2

总结

总结目录：

1.对题目进行分析，给出第二问为什么要求升序序列的证明。
2.给出求最长升序序列，最长降序序列的代码异同（哪些语句受到影响）。比较的因素有：寻找左右边界，升序降序，严格大于和大于等于。
3.给出了lower_bound和upper_bound的使用总结

1 题目分析与相关证明

第一问很简单，就是求一个最长的降序（小于等于）的子序列。

第二问我解释以下为什么是求最长升序列的长度。我们不妨假设最少需要k组才能完成拦截。那么如果从第i组（1<=i<=k)里任意选一个高度记为hi，那么一定可以从第i+1组里面选一个hi+1使得hi+1>hi的。

为什么呢？因为假设你从第i+1组里面找不到这样的hi+1比hi大，那就说明第i+1组里面所有导弹的高度都小于hi，那么第i+1组的所有导弹就一定可以合并到第i组中，这样组数就会减少，这和我们一开始的假设最少也需要k组才能完成拦截是矛盾的！所以一定可以从第i+1组里找到hi+1>hi。同理可以找到hi+3>hi+2>hi+1>hi。

因此，所有的k组一定可以找到h1,h2,…hk形成一个上升序列，该序列的长度为k。

接下来，我们假设数组中的最长上升子序列的长度为p,那么由于这是最长的，因此一定有p>=k，因为k不一定是最长的。接下来，对于最长升序子序列来说，每一个元素一定是不属于同一个组的，因为如果属于同一个组那么就不满足同一个组内是下降序列的要求了。那么我们对于长度为P的最长升序子序列，我们不妨将它的元素记为a1,a2,…ap。那么就有a1属于一个组，假设组的号码为b1，a2属于一个组，组号码为b2。注意，我们并没有说b1和b2是相邻的数，我们只知道他们是不同的数。所以，总共有k个组，那么就说明了k组的总数至少要比所有的p个组要大（因为组数并不要求是连续的，只是要求是不同的），因此k>=p。

综上，由于p>=k,p<=k，因此p=k。因此我们只需要求最长上升子序列即可。

2 比较上升序列和下降序列代码的异同

O（n^2)的方法理解比较简单，就体现在a[i] <= a[j]就可以判断是严格小于，还是小于等于了，修改的时候也是根据题意修改这个比较符号<=即可。

int MaxDesend(int a[], int n) {
	//求长度为n的a[]的最长不上升数组长度,O(n^2)方法
	int dp[100000];//dp[i]定义：以a[i]为结尾的最长不上升数组的长度
	for (int i = 0; i < n; i++)
		dp[i] = 1;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < i; j++) {
			if (a[i] <= a[j]) {//此处的<=体现了不上升，如果严格的话改为<
				dp[i] = max(dp[i], dp[j] + 1);
			}
		}
	}
	int res = 0;
	for (int i = 0; i < n; i++) {
		res = max(res,dp[i]);
	}
	return res;
}

O（nlogn)的方法，二分方法

如果是最长升序序列，整个dp是升序的，我们寻找的是左边界，即第一个大于target的数字，将其替换为target，如果不存在大于target的数字，那么说明target是最大的，将其push_back到dp尾部。如果是降序的，我们寻找的是右边界，即从左往右第一个严格小于target的数字，将其替换为target，如果不存在小于target的数字，说明target是最小的，将其push_back到dp尾部。

左边界与右边界的差别？

左边界与右边界是相对于target来说的，以target==4为例子，升序序列{1,4,4,5}它的左边界为下标1，右边界为下标2。至于具体左边界是取0还是1，右边界取2还是3，看具体的代码和问题，但是基本的概念就是左右边界是相对于target来说的。 因此在本例中，升序找左边界，降序找右边界很正常！（比如{20,15,10,10,10,5},target=10,那么显然要用10替换5，即10的右边界，而不是用10替换15，即10的左边界）

二分法中升序与降序的影响

二分模板如下，可以看到，查找左边界还是右边界，影响的是dp[mid]==target的情况；

而原序列是升序还是降序，影响的是收缩的边界的方向（即dp[mid]!=target的情况），这个可以通过画图来解决。因为收缩边界的本质就是比较dp[mid]和target的大小，然后进行边界收缩。

while (left < right) {
			int mid = (left + right) / 2;
			if (dp[mid] == target) {
				left = mid + 1;//这一步受寻找右边界还是左边界影响
			}
			else if (dp[mid] > target) {
				left = mid + 1;//这一步受数列是升序还是降序影响
			}
			else if (dp[mid] < target) {
				right = mid;
			}
		}//跳出循环时right为第一个小于target的值，而right-1为第一个大于等于target的值

严格上升下降的影响

以降序序列为例子，如果查找右边界，跳出的时候left==right，并且right一定是严格小于target的。而实际的右边界是right-1，因此我们严格小于还是小于等于取决于对dp[right-1]的处理。
假设right-1就是target，说明此时子序列的最后一位就是target，如果不严格的话直接push_back，严格的话那就什么都不处理。
但是如果right-1不是target，那么right-1一定是比target大的数而right一定是比target小的数，那么就可以根据需要进行处理了，这题是将right进行替换。

具体的降序代码

int MaxDesendFast(int a[], int n) {
	//求最长不上升数组的O（nlogn)方法
	int dp[100005];//定义dp[i]为长度为i+1的下降序列的最后一个元素的最大值
	int cnt = 0;
	for (int i = 0; i < n; i++) {
		//寻找从左边起第一个小于a[i]的数,没有就push_back
		//相当于寻找右边界
		int left = 0;
		int right = cnt;
		int target = a[i];
		while (left < right) {
			int mid = (left + right) / 2;
			if (dp[mid] == target) {
				left = mid + 1;//这一步受寻找右边界还是左边界影响
			}
			else if (dp[mid] > target) {
				left = mid + 1;//这一步受数列是升序还是降序影响
			}
			else if (dp[mid] < target) {
				right = mid;
			}
		}//跳出循环时right为第一个小于target的值，而right-1为第一个大于等于target的值

		//下面的语句适用于小于等于的情况，即相等也可以push_back（因为二分产生的right严格小于target）
		if (right == cnt)cnt++;//如果right指向超尾，那么target就是最小的(严格小于，排除了等于的可能），只能接在后面，此时dp[right]=target，情况唯一
		dp[right] = target;//如果right不是指向超尾,而是比如指向最后一个元素，说明right比target小，那么可以用dp[right]=target替换它，情况唯一
		

		//下面说明以下严格小于的情况,即相等的时候不可以push_back
		//if (right == cnt) {//已经指向超尾了，此时right-1可能是大于target的，也可能是等于target的，分开判断;但right是严格小于target的，如果right是超尾，说明不存在这样的值
		//	if (dp[right - 1] == target)continue;//等于的情况，我们不做push_back,cnt不变
		//	else if (dp[right - 1] > target) {//此时target就是最小值，可以push_back
		//		cnt++;
		//		dp[right] = target;
		//	}
		//}
		//else {//正常情况下找到一个严格小于的数，直接赋值
		//	dp[right] = target;
		//}
		
	}
	return cnt;
}

3 关于lower_bound与upper_bound的总结

这一部分注意是关于比较器的说明，普通的lower_bound寻找左到右第一个大于等于target的数，而upper_bound寻找第一个严格大于target的数。
使用了greater比较器后，lower_bound寻找第一个小于等于target的数，而upper_bound寻找第一个严格小于target的数。

完整代码

#include<iostream>
#include<algorithm>
#include<functional>
using namespace std;

int MaxDesend(int a[], int n) {
	//求长度为n的a[]的最长不上升数组长度,O(n^2)方法
	int dp[100000];//dp[i]定义：以a[i]为结尾的最长不上升数组的长度
	for (int i = 0; i < n; i++)
		dp[i] = 1;

	for (int i = 0; i < n; i++) {
		for (int j = 0; j < i; j++) {
			if (a[i] <= a[j]) {//此处的<=体现了不上升，如果严格的话改为<
				dp[i] = max(dp[i], dp[j] + 1);
			}
		}
	}
	int res = 0;
	for (int i = 0; i < n; i++) {
		res = max(res,dp[i]);
	}
	return res;
}

int MaxDesendFast(int a[], int n) {
	//求最长不上升数组的O（nlogn)方法
	int dp[100005];//定义dp[i]为长度为i+1的下降序列的最后一个元素的最大值
	int cnt = 0;
	for (int i = 0; i < n; i++) {
		//寻找从左边起第一个小于a[i]的数,没有就push_back
		//相当于寻找右边界
		int left = 0;
		int right = cnt;
		int target = a[i];
		while (left < right) {
			int mid = (left + right) / 2;
			if (dp[mid] == target) {
				left = mid + 1;//这一步受寻找右边界还是左边界影响
			}
			else if (dp[mid] > target) {
				left = mid + 1;//这一步受数列是升序还是降序影响
			}
			else if (dp[mid] < target) {
				right = mid;
			}
		}//跳出循环时right为第一个小于target的值，而right-1为第一个大于等于target的值

		//下面的语句适用于小于等于的情况，即相等也可以push_back（因为二分产生的right严格小于target）
		if (right == cnt)cnt++;//如果right指向超尾，那么target就是最小的(严格小于，排除了等于的可能），只能接在后面，此时dp[right]=target，情况唯一
		dp[right] = target;//如果right不是指向超尾,而是比如指向最后一个元素，说明right比target小，那么可以用dp[right]=target替换它，情况唯一
		

		//下面说明以下严格小于的情况,即相等的时候不可以push_back
		//if (right == cnt) {//已经指向超尾了，此时right-1可能是大于target的，也可能是等于target的，分开判断;但right是严格小于target的，如果right是超尾，说明不存在这样的值
		//	if (dp[right - 1] == target)continue;//等于的情况，我们不做push_back,cnt不变
		//	else if (dp[right - 1] > target) {//此时target就是最小值，可以push_back
		//		cnt++;
		//		dp[right] = target;
		//	}
		//}
		//else {//正常情况下找到一个严格小于的数，直接赋值
		//	dp[right] = target;
		//}
		
	}
	return cnt;
}

int MaxDesendSTL(int a[], int n) {
	//使用STL来求下降数组的右边界
	int dp[100000];
	int cnt = 0;
	for (int i = 0; i < n; i++) {
		int target = a[i];
		auto pos = upper_bound(dp, dp + cnt, target,greater<int>());//返回第一个小于target的数,lower_bound和upper_bound的使用和序列是否有序无关
		if (pos == (dp + cnt))cnt++;
		*pos = target;
	}
	return cnt;
}


int MaxRise(int a[], int n) {
	//求长度为n的a[]的最长上升数组，O(nlogn)方法
	int dp[100000];//dp[i]定义为长度为长度为i+1的上升序列的最后一个元素的最小值
	int cnt = 0;//模拟向量vector,用于计数最长上升数组的长度

	for (int i = 0; i < n; i++) {
		//对于每一个新的数，需要搜索它在dp中的左边界（第一个比它大的数)
		int target = a[i];
		int left = 0;
		int right = cnt;
		while (left < right) {
			int mid = (left + right) / 2;
			if (dp[mid] == target) {
				right = mid;
			}
			else if (dp[mid] > target) {
				right = mid;
			}
			else if (dp[mid] < target) {
				left = mid + 1;
			}
		}//跳出循环时left就是左边界,指向第一个比它大的数
		if (left == cnt)cnt++;
		dp[left] = target;
	}
	return cnt;
}

int MaxRiseSTL(int a[], int n) {
	//该函数寻找数组a[]的最大升序子序列，但使用STL的lower_bound求数组的左边界
	int dp[100005];
	int cnt = 0;
	for (int i = 0; i < n; i++) {
		int target = a[i];
		auto pos = lower_bound(dp, dp + cnt, target);//使用lower_bound寻找左边界，返回值是迭代器类型
		if (pos == (dp + cnt))cnt++;
		*pos = target;
	}
	return cnt;
}

int main() {
	int height[100000];
	int n = 0;//数组长度
	while (cin >> height[n++]);
	n--;
	//cout<<MaxDesendFast(height, n) << endl;
	//cout << MaxRise(height, n)<<endl;
	cout<<MaxDesendSTL(height, n) << endl;
	cout << MaxRiseSTL(height, n)<<endl;
	return 0;
}