谈国平1. 最长上升子序列问题概述
最长上升子序列（Longest Increasing Subsequence, LIS）是动态规划领域最经典的入门问题之一。给定一个无序的整数序列，我们需要找到其中最长的严格递增子序列的长度。这里的子序列不要求连续，但必须保持原始序列中的相对顺序。
举个例子，对于序列 [10, 9, 2, 5, 3, 7, 101, 18]，其最长上升子序列是 [2, 3, 7, 101]，长度为4。这个问题看似简单，但它揭示了动态规划解决序列问题的核心思想，也是许多复杂算法的基础构件。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 动态规划解法详解
2.1 状态定义与转移方程
我们定义dp[i]表示以第i个数字结尾的最长上升子序列的长度。这个状态定义是解决LIS问题的关键，它抓住了"以某个位置结束"这一重要特征。
状态转移方程可以表示为：
dp[i] = max(dp[j]) + 1，其中0 ≤ j < i且nums[j] < nums[i]
这个方程的含义是：对于每个位置i，我们查看前面所有比nums[i]小的元素，找到其中dp值最大的那个，然后在其基础上加1。如果没有这样的j存在，那么dp[i] = 1（即自身构成一个长度为1的子序列）。
2.2 算法实现步骤
基于上述思路，我们可以写出如下Python实现：
python复制def lengthOfLIS(nums):
if not nums:
return 0
dp = [1] * len(nums)
for i in range(1, len(nums)):
for j in range(i):
if nums[j] < nums[i]:
dp[i] = max(dp[i], dp[j] + 1)
return max(dp)
这个实现的时间复杂度是O(n²)，其中n是序列长度。外层循环遍历每个元素，内层循环检查所有前面的元素。
2.3 算法复杂度分析
空间复杂度：O(n)，用于存储dp数组
时间复杂度：O(n²)，因为有两层嵌套循环
虽然这个解法不是最优的，但它清晰地展示了动态规划解决序列问题的基本模式，是理解更复杂算法的基础。
3. 优化解法：贪心+二分查找
3.1 优化思路
我们可以通过维护一个潜在的最优子序列来优化时间复杂度。具体做法是维护一个数组d，其中d[i]表示长度为i+1的上升子序列的最小末尾元素。
这个方法的巧妙之处在于：通过保证d数组是有序的，我们可以使用二分查找来快速定位更新位置，将时间复杂度降低到O(n log n)。
3.2 优化算法实现
python复制def lengthOfLIS(nums):
d = []
for num in nums:
if not d or num > d[-1]:
d.append(num)
else:
left, right = 0, len(d) - 1
loc = right
while left <= right:
mid = (left + right) // 2
if d[mid] >= num:
loc = mid
right = mid - 1
else:
left = mid + 1
d[loc] = num
return len(d)
这个实现中，我们遍历每个数字，如果它大于d数组的最后一个元素，就扩展d数组；否则，通过二分查找找到第一个不小于它的元素进行替换。这种方法保证了d数组始终保持有序，且最终d的长度就是LIS的长度。
3.3 优化效果对比
| 指标 | 基础DP解法 | 优化解法 |
|---|---|---|
| 时间复杂度 | O(n²) | O(n log n) |
| 空间复杂度 | O(n) | O(n) |
| 适用场景 | 教学理解 | 实际应用 |
4. 典型应用场景与变种
4.1 实际应用案例
最长上升子序列问题在现实中有多种应用：
- 基因序列分析中的相似性比较
- 金融领域中的最长增长趋势分析
- 计算机科学中的文件差异比较算法
4.2 常见变种问题
- 最长不下降子序列：允许相等的元素
- 最长递减子序列：将比较条件反转
- 二维LIS问题：如信封嵌套问题
- 带权LIS：每个元素有权重，求最大权重和
4.3 解题技巧总结
- 对于序列问题，考虑"以i结尾"的状态定义往往有效
- 当O(n²)复杂度不够时，考虑能否用二分查找优化
- 注意边界条件：空序列、全递增序列、全递减序列
- 输出具体序列而不仅是长度时，需要额外记录路径
5. 常见错误与调试技巧
5.1 典型错误模式
- 初始化错误：忘记将dp数组初始化为1
- 边界条件处理不当：空输入或单元素输入
- 状态转移条件错误：混淆了≤和<的区别
- 最终结果获取错误：不是dp[-1]而是max(dp)
5.2 调试建议
- 打印dp数组的中间状态，观察是否符合预期
- 对小样例手动计算，与程序输出对比
- 特别注意循环的起始和终止条件
- 对于优化解法，打印d数组的变化过程
5.3 测试用例设计
好的测试用例应该包含：
- 空序列
- 单元素序列
- 全递增序列
- 全递减序列
- 随机序列
- 有重复元素的序列
例如：
python复制test_cases = [
([], 0),
([1], 1),
([1,2,3,4], 4),
([4,3,2,1], 1),
([10,9,2,5,3,7,101,18], 4),
([2,2,2,2], 1)
]
6. 算法扩展与进阶
6.1 输出具体序列
有时我们需要输出具体的LIS而不仅是长度。这可以通过在dp过程中记录前驱节点来实现：
python复制def getLIS(nums):
dp = [1] * len(nums)
prev = [-1] * len(nums)
for i in range(1, len(nums)):
for j in range(i):
if nums[j] < nums[i] and dp[j] + 1 > dp[i]:
dp[i] = dp[j] + 1
prev[i] = j
max_len = max(dp)
max_index = dp.index(max_len)
result = []
while max_index != -1:
result.append(nums[max_index])
max_index = prev[max_index]
return result[::-1]
6.2 树状数组优化
对于某些特定场景，可以使用树状数组（Fenwick Tree）进一步优化：
python复制class FenwickTree:
def __init__(self, size):
self.size = size
self.tree = [0] * (self.size + 1)
def update(self, index, value):
while index <= self.size:
self.tree[index] = max(self.tree[index], value)
index += index & -index
def query(self, index):
res = 0
while index > 0:
res = max(res, self.tree[index])
index -= index & -index
return res
def lengthOfLIS(nums):
if not nums:
return 0
unique_sorted = sorted(set(nums))
rank = {v: i+1 for i, v in enumerate(unique_sorted)}
ft = FenwickTree(len(unique_sorted))
res = 0
for num in nums:
current = ft.query(rank[num] - 1) + 1
res = max(res, current)
ft.update(rank[num], current)
return res
这种方法在特定约束下可以达到O(n log n)时间复杂度，适用于元素范围较大的情况。
6.3 与其他算法的关系
LIS问题与许多其他算法有密切联系：
- 可以转化为最长公共子序列(LCS)问题
- 与Dilworth定理相关，涉及偏序集分解
- 在计算几何中用于解决某些平面点集问题
理解这些联系有助于在更复杂的问题中识别出LIS模式，从而应用相应的解法。