最长上升子序列LIS 动态规划 二分查找算法

所谓LIS表示最长上升子序列，是面试的时候非常容易考察的问题。对于一个序列h1,h2,...hN,其中的子序列hi1,hi2,...hik，满足hi1

最容易想到的办法是动态规划，其中它的复杂度是O(n^2)。我们设置dp[i]表示从0~i之内最长的上升子序列的长度。那么对于任意的索引j(0<=j dp[i]，那么就可以把dp[i]更新成dp[j]+1. 这是因为dp[j]表示的是从0到j中最长的上升子序列的长度，当height[i]>height[j]的时候，说明height[i]可以加到从0到j之内上升子序列的末尾形成新的子序列，这个上升子序列的长度是原来的长度+1.当超过了dp[i]的时候就更新dp[i]。

代码的实现如下所示：

int main(){
	int n;
	cin >> n;
	int height[1005];//height是存放序列高度的
	int dp[1005];//dp[i]表示索引i结尾的最大的上升子序列

	for (int i = 0; i < n; i++){
		cin >> height[i];
	}
	dp[0] = 1;//最左边的可以单独看成是一个上升子序列

	int ret = 0;
	for (int i = 1; i < n; i++){
		for (int j = 0; j < i; j++){
			if (height[i] > height[j] && dp[i] <= dp[j] + 1) dp[i] = dp[j] + 1;
			ret = max(ret, dp[i]);
		}
	}
	cout << ret << endl;
	system("pause");
	return 0;
}

显然这个算法的复杂度是O(n^2)，因为对于每一个i都需要遍历从0~i的所有高度，最终的遍历次数是n(n-1),复杂度就是O(n^2)。 那么有没有更好地办法呢？答案是有的，用的是贪心法+二分查找。

同样用height[i]表示第i个数据大小，dp[i]表示长度是i+1的子序列的末尾处的最大值。对于一个上升子序列，从贪心的角度来想，这个上升子序列的最后一个数字越小越好，因为我们需要想这个子序列的末尾添加数字。所以我们需要维护一个dp数组，他表示的是一个上升子序列，且每个元素都是目前能找到的最小值。

当我们发现新的height[i]比dp[pos]这个位置要大的时候，直接加载这个dp[pos]的末尾，形成新的上升序列；当新的height[i]的值要小于等于dp[pos]的时候，那么从dp[0]到dp[pos]这些高度中，一定有一个是大于等于它的，那么把第一个大于等于它的值的那个dp[s] 替换成height[i]，从而使得维护的这个最长上升序列的高度进一步下降，方便贪心法的以后的插入。

int main(){
	int n;
	cin >> n;
	int height[1005];//height是存放序列高度的
	int dp[1005];

	for (int i = 0; i < n; i++){
		cin >> height[i];
	}

	//维护一个dp数组，dp[i]表示i以内的上升序列的结尾的最大值，我们希望他越小越好
	//pos记录的是i以前的最长上升子序列的长度 
	int pos = 0;
	dp[0] = height[0];
	for (int i = 1; i < n; i++){
		if (height[i] > dp[pos]) dp[++pos] = height[i];
		else{
			//从dp[0]到dp[pos]中从左往右找到第一个大于等于height[i]位置的，进行替换
			dp[lower_bound(dp, dp + pos + 1, height[i]) - dp] = height[i];
		}
	}
	cout << pos + 1 << endl;
	system("pause");
	return 0;
}

其中，lower_bound函数是找到第一个大于等于height【i】位置的函数，他用的是二分查找，所以对于每次查找把复杂度从O(n)降低到O(logn)，进而使得全局的复杂度从O(n^2)降低到了O(nlogn).

有关upper_bound()和lower_bound()的用法，请参考：https://blog.csdn.net/hanzhen7541/article/details/99722948