day161—动态规划—最长递增子序列（LeetCode-300）

题目描述

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4

示例 3：

输入：nums = [7,7,7,7,7,7,7]
输出：1

提示：

• 1 <= nums.length <= 2500
• -104 <= nums[i] <= 104

解决方案：

这段代码的核心功能是用迭代版动态规划（DP）求解最长递增子序列（LIS）的长度，相比递归版本更高效且无栈溢出风险，是能稳定处理大数据量（如 n=2500）的经典解法。

核心逻辑

1. DP 数组定义 ：dp[i] 表示「以nums[i]为最后一个元素的最长递增子序列长度」，初始值全为 1（每个元素自身就是一个长度为 1 的递增子序列）。

2. 双层循环迭代计算：

   • 外层循环i遍历每个元素（从 1 开始，因为i=0时无前置元素，dp[0]恒为 1）；
   • 内层循环j枚举i之前的所有元素（j < i），若nums[j] < nums[i]，说明nums[i]可接在nums[j]的递增子序列后，此时更新dp[i] = max(dp[i], dp[j] + 1)（取所有合法前驱的最长长度 + 1）。

3. 全局最大值维护 ：用max_len记录所有dp[i]的最大值（因为 LIS 不一定以最后一个元素结尾），最终返回该值。

关键特点

• 无递归开销：纯迭代实现，避免递归栈溢出，可处理 n=2500 甚至更大的数组；
• 时间复杂度O(n2)、空间复杂度O(n)，在工程中是平衡效率与实现复杂度的最优选择；
• 逻辑直观：通过 "枚举前驱 + 状态转移"，直接体现 LIS 的核心规律 ------ 每个位置的最长递增子序列依赖于其前面更小元素的结果。

总结

1. 核心思路：用 DP 数组自底向上迭代计算每个位置的 LIS 长度，避免重复计算；
2. 关键设计：dp[i]聚焦 "以当前元素结尾" 的子问题，通过双层循环完成状态转移；
3. 功能效果：能高效求解任意长度数组的 LIS 长度，无栈溢出、无超时问题，是 LeetCode 该题的标准通关解法。

以升序数组[1,2,...,2500]为例，最终dp[2499]=2500，max_len=2500，返回正确结果。

函数源码：

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        if (n == 0) return 0;
        // dp[i]：以nums[i]为结尾的最长递增子序列长度
        vector<int> dp(n, 1); // 初始值为1，每个元素自身是一个长度为1的子序列
        int max_len = 1;      // 记录全局最大值
        
        // 迭代计算每个dp[i]，替代递归
        for (int i = 1; i < n; i++) {
            // 枚举前驱j < i，和递归的逻辑完全一致
            for (int j = 0; j < i; j++) {
                if (nums[j] < nums[i]) {
                    dp[i] = max(dp[i], dp[j] + 1);
                }
            }
            max_len = max(max_len, dp[i]);
        }
        return max_len;
    }
};