笔试题17——最长上升子序列（LIS）

最长上升子序列（Longest Increasing Subsequence）问题的大意是：
有一个长度为n的数字序列，求它的所有子序列中长度最大的单调上升的序列长度。
当然，还有最长不下降子序列问题，最长下降子序列问题，最长不上升子序列问题……本质相同，这里不分别介绍。
比如：有长度为7的序列1 7 3 5 9 4 8，它的LIS长度为4，但是LIS不唯一，有1 3 5 9，1 3 5 8，1 3 4 8等等。
通常来说，由于LIS问题有多个解（不同的子序列长度相同），一般求的都是LIS的长度而非序列中的具体数字。
下面介绍它的三种解法：
解法一：通过深度优先遍历（DFS）来解
核心代码如下：

#include <iostream>
#include <vector>
#include <stack>
using namespace std;

int n;
int* a;
stack<int> st;
int count = 0;
int best = 0;

void dfs(int i) {
	if (i == n) {
		if (st.size() > best)
			best = st.size();
		return;
	}
	if (st.empty() || a[i] > st.top()) {
		st.push(a[i]);
		dfs(i + 1);
		st.pop();
	}
	if (st.size() + n - i - 1 > best)
		dfs(i + 1);
}

int main() {
	while (cin >> n) {
		a = new int[n];
		for (int i = 0; i < n; i++)
			cin >> a[i];
		dfs(0);
		cout << best << endl;
		delete[] a;
	}
	return 0;
}

解法二：通过动态规划（DP问题）来解
令A[i]表示输入第i个元素，D[i]表示从A[1]到A[i]中以A[i]结尾的最长子序列长度。对于任意的0 < j <= i - 1，如果A(j) < A(i)，则A(i)可以接在A(j)后面形成一个以A(i)结尾的新的最长上升子序列。对于所有的 0 < j <= i - 1，我们需要找出其中的最大值。
DP状态转移方程：
D[i] = max{ 1, D[j] + 1 } (j = 1, 2, 3, …, i - 1 且 A[j] < A[i])
解释一下这个方程，i，j在范围内：
如果 A[j] < A[i] ，则D[i] = D[j] + 1
如果 A[j] >= A[i] ，则D[i] = 1
核心代码如下：

#include <iostream>
#include <vector>
#include <stack>
using namespace std;

int main() {
	int n, max;
	int a[1001]; //a[i]表示输入第i个元素
	int d[1001]; //d[i]表示以a[i]结尾的最长子序列长度
	while (cin >> n) {
		for (int i = 1; i <= n; i++)
			cin >> a[i];

		max = 0;
		for (int i = 1; i <= n; i++) {
			d[i] = 1;
			for (int j = 1; j <= i - 1; j++) {
				if (a[j] < a[i] && d[i] < d[j] + 1) //d[i] < d[j] + 1这个条件的限制是为了在连续几个d[i]相同时只加一次
					d[i] = d[j] + 1;
			}
			if (d[i] > max) //记录最长子序列
				max = d[i];
		}
		cout << max << endl;
	}
	return 0;
}

解法三：通过二分搜索法来解，时间复杂度为O(nlogn)
算法思想其实已经不是DP了，有点像贪心。复杂度降低是因为这个算法里面用到了二分搜索。本来有N个数要处理是O(n)，每次计算要查找N次还是O(n)，一共就是O(n^2)；现在搜索换成了O(logn)的二分搜索，总的复杂度就变为O(nlogn)了。
具体思路如下：
开一个栈（或数组），每次取栈顶元素top和读到的元素temp做比较，如果temp > top 则将temp入栈；如果temp < top则二分查找栈中的比temp大的第1个数，并用temp替换它。最长序列长度即为栈的大小top。
举例：原序列为1，5，8，3，6，7
栈为1，5，8，此时读到3，用3替换5，得到1，3，8； 再读6，用6替换8，得到1，3，6；再读7，得到最终栈为1，3，6，7。最长递增子序列为长度4。
PS：当出现1，5，8，2这种情况时，栈内最后的数是1，2，8不是正确的序列啊？难道错了？
分析一下，我们可以看出，虽然有些时候这样得不到正确的序列了，但最后算出来的个数是没错的，为什么呢？
想想，当temp>top时，总个数直接加1，这肯定没错；但当temp<top时呢？ 这时temp肯定只是替换了栈里面的某一个元素，所以大小不变，就是说一个小于栈顶的元素加入时，总个数不变。这两种情况的分析可以看出，如果只求个数的话，这个算法比较高效。但如果要求打印出序列时，就只能用DP了（问题：DP如何求序列中的具体数字？）。
核心代码如下：

#include <iostream>
#include <vector>
#include <stack>
using namespace std;

int main() {
	int n, top, temp;
	int stack[1001];
	while (cin >> n) {
		top = 0;
		stack[0] = -(1e9); //为了确保第一个数字能放进去
		for (int i = 0; i < n; i++) {
			cin >> temp;
			if (temp > stack[top]) //比栈数组元素大就入栈
				stack[++top] = temp;
			else
			{
				int low = 1, high = top;
				int mid;
				while (low <= high) {  //二分搜索法，复杂度为o(logn)，检索stack中比temp大的第一个数，并替换它
					mid = (low + high) / 2;
					if (temp > stack[mid])
						low = mid + 1;
					else
					{
						high = mid - 1;
					}
				}
				stack[low] = temp; //stack中比temp大的第一个数位置在当前的low处
			}
		}
		cout << top << endl; //返回当前stack数组的长度，即为最长上升子序列长度
	}
	return 0;
}

核心代码2如下：

#include <iostream>
#include <vector>
using namespace std;

int main() {
	int n, tmp, mid;
	int* a = new int[n];
	int* b = new int[n+1];
	int len = 1; //记录最长上升子序列长度，至少为1
	int start = 0;
	int end; 
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> tmp;
		a[i] = tmp;
		b[i + 1] = a[i];
	}

	for (int i = 1; i < n; i++) {
		if (a[i] > b[len]) {
			len++;
			b[len] = a[i];
		}
		else
		{
			start = 1;
			end = len;
			while (start <= end) {
				mid = (start + end) / 2;
				if (a[i] > b[mid]) {
					start = mid + 1;
				}
				else
				{
					end = mid - 1;
				}
			}
			b[start] = a[i];
		}
	}
	cout << len << endl;
	return 0;
}

来源自：https://blog.csdn.net/Wabrush/article/details/73003712