力扣第300题 最长递增子序列

前言

记录一下刷题历程 力扣第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

分析

我们使用动态规划，请看下图
根据图中我们可以看出以2结尾的子序列有一个长度为1，所以dp[0]=1.
以5为结尾的子序列有两个，在我们递归的过程中首先会到达长度为2的子序列也就是[2,5]此时dp[1]=2.下一次到达以5结尾的子序列，我们可以让他和已经保存的长度作比较，发现比之前保存的要小，所以还是2.当我们递归到以4为结尾的子序列时我们发现有两个，我们把先递归到的长度保存一下dp[2]=2.当我们下一次遍历到以4为结尾的子序列时，再次作比较。
通过这个例子，dp[n]时以第n个元素结尾的最长子序列。
nums=[2,5,4]
dp[0]=1
dp[1]=2
dp[2]=dp[0]+1(因为4<5所以与5无关的)
dp[n]=max{dp[i]+1} nums[n]>nums[i]

代码如下：

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> dp(nums.size(), 1); // 初始化 DP 数组，长度和 nums 一样，初始值都为 1
        int maxres = 1; // 用于存储最长递增子序列的长度
        
        for (int i = 0; i < nums.size(); i++) { // 遍历每一个元素
            for (int j = 0; j < i; j++) { // 对于每个元素 i，遍历它之前的所有元素 j
                if (nums[i] > nums[j]) { // 如果当前元素 nums[i] 大于之前的元素 nums[j]
                    dp[i] = max(dp[i], dp[j] + 1); // 更新 dp[i]，表示以 nums[i] 结尾的最长递增子序列
                    maxres = max(maxres, dp[i]); // 更新全局最长递增子序列的长度
                }
            }
        }
        
        return maxres; // 返回最长递增子序列的长度
    }
};

解释注释

1.DP 数组的初始化：

vector dp(nums.size(), 1);
dp[i] 表示以 nums[i] 结尾的最长递增子序列的长度。
初始时，每个元素的 DP 值都为 1，因为每个元素单独成序列时，其长度为 1。

2.最长递增子序列长度的初始化：

int maxres = 1;
maxres 用来记录目前找到的最长递增子序列的长度，初始值为 1，因为至少有一个元素存在。

3.双重循环：

for (int i = 0; i < nums.size(); i++) {
for (int j = 0; j < i; j++) {
外层循环遍历数组的每一个元素 i。
内层循环遍历 i 之前的所有元素 j，目的是检查以 nums[i] 为结尾的递增子序列的最长长度。

4.更新 DP 数组：

if (nums[i] > nums[j]) {
dp[i] = max(dp[i], dp[j] + 1);
maxres = max(maxres, dp[i]);
}
当 nums[i] > nums[j] 时，说明 nums[i] 可以接在 nums[j] 后面形成一个递增子序列。
更新 dp[i]，表示以 nums[i] 结尾的最长递增子序列长度，取当前的 dp[i] 和 dp[j] + 1 中的较大值。
同时更新 maxres，确保记录全局最长递增子序列的长度。

时间复杂度

时间复杂度： O(n^2)，因为存在双重循环，每次比较都需要 O(1) 的时间。