文章目录

• • 1. 最长连续递增序列
  • 2. 最长递增子序列
  • 3. 最长递增子序列的个数

1. 最长连续递增序列

给定一个未经排序的整数数组，找到最长且连续递增的子序列，并返回该序列的长度。连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], …, nums[r - 1], nums[r]] 就是连续递增子序列。

贪心法，时间复杂度O(n)，空间复杂度O(1)

class Solution {
public:int findLengthOfLCIS(vector& nums) {int maxl = 0;int len = 1; //连续数组最少是1for(int i = 1; i < nums.size(); ++i){if(nums[i] > nums[i - 1]){++len;}else{//不连续，从头开始if(maxl < len){maxl = len;}len = 1;}}return len > maxl ? len : maxl;}
};

动态规划也可以做，只不过需要额外的空间n

2. 最长递增子序列

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

动态规划，dp[i]表示i之前（包括i）最长递增子序列的长度为dp[i]，本题最关键的是要想到dp[i]由哪些状态可以推出来，并取最大值，那么很自然就能想到递推公式：dp[i] = max(dp[i], dp[j] + 1);
时间复杂度O(n^2)，空间复杂度O(n)

class Solution {
public:int lengthOfLIS(vector& nums) {int size = nums.size();vector dp(size,1);int maxl = 1;for(int i = 1; i < size; ++i){for(int j = 0; j < i; ++j){if(dp[j] + 1 > dp[i] && nums[i] > nums[j]){dp[i] = dp[j] + 1;}if(maxl < dp[i]){maxl = dp[i];}}}return maxl;}
};

3. 最长递增子序列的个数

给定一个未排序的整数数组 nums ， 返回最长递增子序列的个数 。注意这个数列必须是 严格 递增的。

动态规划法，这个题是最长递增子序列的进阶版本，需要增加一个数组count，count[i]表示以nums[i]为结尾的字符串，最长递增子序列的个数为count[i]，count[i]的更新

• 在nums[i] > nums[j]前提下，如果在[0, i-1]的范围内，找到了j，使得dp[j] + 1 > dp[i]，说明找到了一个更长的递增子序列。那么以j为结尾的子串的最长递增子序列的个数，就是最新的以i为结尾的子串的最长递增子序列的个数，即：count[i] = count[j]
• 在nums[i] > nums[j]前提下，如果在[0, i-1]的范围内，找到了j，使得dp[j] + 1 == dp[i]，说明找到了两个相同长度的递增子序列。那么以i为结尾的子串的最长递增子序列的个数 就应该加上以j为结尾的子串的最长递增子序列的个数，即：count[i] += count[j]

时间复杂度O(n^2)，空间复杂度O(n)

class Solution {
public:int findNumberOfLIS(vector& nums) {vector dp(nums.size(), 1);vector count(nums.size(), 1);int result = 0;int len = 1;for(int i = 0; i < nums.size(); ++i){for(int j = 0; j < i; ++j){if(nums[j] < nums[i]){if(dp[j] + 1 > dp[i]){dp[i] = dp[j] + 1;count[i] = count[j];}else if(dp[j] + 1 == dp[i]){count[i] += count[j];}}}if(len < dp[i]){len = dp[i];result = count[i];}else if(len == dp[i]){result += count[i];}}return result;}
};