最长上升子序列问题总结

最长上升子序列问题总结

DP

复杂度 \(O(n^2)\)

对于dp[i]我们保存以i结尾的最长上升子序列，显然可以得到递推式

\(dp[i] = max(dp[j] + 1) \space 1 \le j < i \space and \space a[j] < a[i]\)

CODE

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

// dp[i] 表示以第i个数结尾的最大上升子序列
// 对于第i-1个数，若其小于dp[i] 显然dp[i - 1] + 1 时dp[i]集合的一部分
// 否则dp[i]等于

int main() {
	int n; cin >> n;
	vector<int> a(n + 1), dp(n + 1);
	for (int i = 1; i <= n; i ++) cin >> a[i];
	for (int i = 1; i <= n; i ++) {
		if (i == 1) dp[i] = 1;
		else {
		    dp[i] = 1;
			for (int j = 1; j <= i - 1; j ++) {
				if (a[j] < a[i]) dp[i] = max(dp[i], dp[j] + 1);
			}
		}
	}
	cout << *max_element(dp.begin() + 1, dp.end());
}

单调栈+二分

复杂度\(O(nlogn)\)

设函数\(f(x)表示长度为x的序列中最后一个数的最小数\)

可以得到以下结论

​ \(f(x)\) 是严格单调递增函数, (假设\(f(x)\)非严格单调递增，即存在\(f(x) \ge f(y), x \le y\)，因为长度为\(y\)的子序列一定包含了长度为\(x\)的子序列，所以保证了存在长度为\(x\)的子序列末端的数小于\(f(y)\)这与上述假设相矛盾）

​ 知道了\(f(x)\)是严格单增函数，我们通过维护每个x的末端数字，可以得到最终的长度。

​ 如何维护？我们从\(1\)到\(n\)进行枚举，如果当前数大于维护序列的最后一个数，就插入该数，若存在大于等于这个数的，就进行替换，保证序列单调递增（这个思路，也可以贪心的理解，我每次维护若存在某个数小于我末端的这个数，那我以这个数结尾会比较好，而大于该数的第一个数，是为了维护单调递增）

CODE

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

const int N = 1e5 + 10;

int a[N];
int stk[N];
/*
	f(x) 表示长度为x的最长上升子序列的最后一个值为多少(如果有多个，则取最小的)
		1. 显然f(x)是一个单调递增的函数
		2. 通过维护f(x) 内的值， 因为顺序遍历，所以遍历到更小的一定能把前面的更新了
*/
int main() {
	int n, len = 0;
	cin >> n;
	stk[0] = -2e9;
	for(int i = 1; i <= n; i ++) {
		cin >> a[i];
		int l = 0, r = len;
		while(l < r) {
			int mid = l + r + 1 >> 1;
			if(stk[mid] < a[i]) l = mid;
			else r = mid - 1;
		}
		stk[l + 1] = a[i];
		len = max(len ,l + 1);
	}
	cout << len;
}

例题

快乐的尽头 (单调栈加回溯)

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

const int N = 1e5 + 10;

int a[N], stk[N];

vector<int> record[N];

/*
    record小标记录的数单调递减， 下标也单调递增
    我们想要满足条件的最小下标
*/

int main() {
	int n, len = 0;
	cin >> n;
	for(int i = 1; i <= n; i ++) cin >> a[i];
	stk[0] = -1;
	for(int i = 1; i <= n; i ++) {
		int l = 0, r = len;
		while(l < r) {
			int mid = l + r + 1 >> 1;
			if(stk[mid] < a[i]) l = mid;
			else r = mid - 1;
		}
		len = max(l + 1, len);
		record[l + 1].push_back(i);
		stk[l + 1] = a[i];
	}
	cout << len << "\n";
//     for(int i = 1; i <= len; i ++) {
//         cout << "len: " << i << "->";
//         for(int j = 0; j < record[i].size(); j ++) {
//             cout << record[i][j] << " \n"[j == (int) record[i].size() - 1];
//         }
//     }
	vector<int> curr;
	for(int i = len; i >= 1; i --) {
		if(i == len) curr.push_back(record[i][0]);
		else {
			int pos = (int) record[i].size() - 1;
 			// 二分第一个满足条件的 即小于这个数
            int l = 0, r = pos;
            while(l < r) {
                int mid = l + r >> 1;
                if(a[record[i][mid]] < a[curr.back()]) r = mid;
                else l = mid + 1;
            }
			curr.push_back(record[i][l]);
		}	
	}
	for(int i = (int) curr.size() - 1; i >= 0; i --) {
		cout << curr[i] << " \n"[i == 0];
	}
}