NlogN 求最长不下降子序列（LIS）
最长不下降子序列是一道非常经典的题目，我们假设题目如下：
有一个数组 $ a $，现在要从中抽取一个严格上升的子序列（子序列就是你可以从原序列里删除一些数，保留一部分数得到的新数列）（严格上升也就是不能相等只能递增），现在要求出这个子序列最长有多长？
举例来说，假设有一个数组 a = [10, 9, 2, 5, 3, 7, 101, 18]。这个数组的最长上升子序列是 [2, 3, 7, 101]，这是从原数组中第3, 5, 6, 7个位置选取得到的，长度为4。(当然最后一个数字换成 18 也可以)
平方做法
通常来讲，平方做法很容易想到，我们开一个数组 $ f $ ，用 $ f_i $ 表示以 $ a_i $ 结尾的 LIS 的长度。我们从左往右计算每一个 $ f_i $ ，每一个 $ f_i $ 可能由 \(f_1, f_2...f_{i-1}\)得到。比方说假如 $ a_i > a_j $，那么 \(a_i\) 就可以接到 $ f_{i-1} $ 表示的序列后面，长度加一，枚举所有之前的 f，取最大值，最终就可以计算出来。
#include <vector>
#include <algorithm>
using namespace std;
int longestIncreasingSubsequence(const vector<int>& a) {
int n = a.size();
vector<int> f(n, 1); // 初始化每个元素的LIS长度为1
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (a[i] > a[j]) {
f[i] = max(f[i], f[j] + 1);
}
}
}
return *max_element(f.begin(), f.end()); // 返回f中的最大值，即最长上升子序列的长度
}
int main() {
vector<int> a = {10, 9, 2, 5, 3, 7, 101, 18};
int result = longestIncreasingSubsequence(a);
return result;
}
N log N 做法
更高效的方法是通过维护一个数组 $ tail $ 来实现，其中 $ tail_i $ 存储长度为 i 的所有上升子序列中末尾最小的元素（比如 $ tail_4 $ 表示所有长度为 4 的 LIS 里最后一个数字最小能达到多少）。在更新过程中，我们使用二分搜索来确定一个元素应当放置在 $ tail $ 中的位置。
我们还是从左向右来枚举，对于每个元素 $ a_i $，在 \(tail\) 中找到第一个大于 $ a_i $ 的位置。
- 如果找到这样的位置，即表示之前有一个序列的末尾可以被替换，所以修改其 $ tail $ 值为新 $ a_i $
- 如果没有找到，说明 $ a_i $ 比之前所有数字都大，那么把 $ a_i $ 追加到 $ tail $ 末尾，最长的上升序列长度成功加1.
对于 $ tail $ 来说，下标越大，条件越难满足，则能达到的最小值越大，所以 $ tail $ 显然是严格递增的，这不难理解，而每一次操作也维持了 $ tail $ 的单调性。
举例来说，现在\(tail = [3, 5, 6, 19, 25]\)，而当前 $ a_i $ 为 8，可以找到 $ tail_4 = 19$ 这表明在我之前出现过一个长度为4，以 19 结尾的序列，以及一个长度为3，以小于8结尾的序列，那么这个长度为3的序列可以接上8，替换掉原来的19，一定更优
#include <vector>
#include <algorithm>
using namespace std;
int longestIncreasingSubsequence(const vector<int>& a) {
vector<int> tail;
for (int x : a) {
auto it = lower_bound(tail.begin(), tail.end(), x);
if (it == tail.end()) {
tail.push_back(x); // 如果x大于tail中所有元素，追加到末尾
} else {
*it = x; // 替换为更小的值，保持序列最小
}
}
return tail.size(); // tail的大小就是最长上升子序列的长度
}
int main() {
vector<int> a = {10, 9, 2, 5, 3, 7, 101, 18};
int result = longestIncreasingSubsequence(a);
return result;
}
获得具体的数列
除了得到最长长度，此方法也是支持把序列获取到的，增加一个数组，每一次更新 tail 时，来记录每个元素的前一个元素的索引，这里附加上 chatgpt 的代码：
def longest_non_decreasing_subsequence(arr):
from bisect import bisect_right
if not arr:
return 0, []
dp = [] # 存放各长度最长不下降子序列的最小结尾元素的值
predecessor = [-1] * len(arr) # 前驱元素的索引
indices = [] # 存放各长度最长不下降子序列的最小结尾元素的索引
for i, x in enumerate(arr):
pos = bisect_right([arr[idx] for idx in indices], x)
if pos < len(indices):
indices[pos] = i
predecessor[i] = indices[pos-1] if pos > 0 else -1
else:
indices.append(i)
predecessor[i] = indices[-2] if len(indices) > 1 else -1
# 回溯找到最长不下降子序列
n = len(indices)
sequence = [0] * n
k = indices[-1]
for j in range(n-1, -1, -1):
sequence[j] = arr[k]
k = predecessor[k]
return n, sequence
# 示例
arr = [10, 9, 2, 5, 3, 7, 101, 18]
length, sequence = longest_non_decreasing_subsequence(arr)
print("Length:", length) # 输出长度
print("Sequence:", sequence) # 输出序列
严格上升和不下降
要从求最长严格上升子序列变为求最长不下降子序列（也就是允许序列中的元素相等），主要修改的部分就是二分查找部分。在严格上升的场景中，tail 不会出现相等值，我们寻找的是第一个大于等于当前元素的位置，而在不下降的场景中，要找到的是第一个大于当前元素的位置。
举例子来说，当要求变为严格不下降，$ tail $ 就有可能出现相等值，假设 $ tail = [1, 2, 2, 3, 3, 3, 5] $，且下一个 \(a_i\) 为 2。那么应该更新 \(a_2\) 第一个3。而扩展 $ tail $ 的条件也放宽为大于等于，具体代码就不再展示。
