力扣第674题 最长连续递增序列 C++ 动态规划 + 贪心 附Java代码

题目

674. 最长连续递增序列

简单

相关标签

数组

给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。

连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。

示例 1：

输入：nums = [1,3,5,4,7]
输出：3
解释：最长连续递增序列是 [1,3,5], 长度为3。
尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为 5 和 7 在原数组里被 4 隔开。 

示例 2：

输入：nums = [2,2,2,2,2]
输出：1
解释：最长连续递增序列是 [2], 长度为1。

提示：

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

思路和解题方法

1. 首先判断数组大小是否小于等于1，如果是，则直接返回数组大小，因为连续递增子序列的长度最小为1。
2. 创建一个大小为nums.size()的动态数组dp，用于存储以nums[i]结尾的最长连续递增子序列的长度，默认赋初始值为1。同时，初始化最长连续递增子序列的长度为0。
3. 遍历数组nums，从第二个元素开始，判断当前元素nums[i]是否大于前一个元素nums[i-1]，如果是，则可以将nums[i]加入到以nums[i-1]结尾的最长连续递增子序列中，从而得到以nums[i]结尾的最长连续递增子序列的长度。更新dp[i]。
4. 比较dp[i]与ans的大小关系，更新最长连续递增子序列的长度。
5. 最后，返回最长连续递增子序列的长度。

复杂度

        时间复杂度:

                O(n)

时间复杂度为O(n)，其中n为输入数组nums的长度。这是因为代码中使用了一次循环来遍历整个数组，每个元素的处理都只需要常数时间。

        空间复杂度

                O(n)

空间复杂度为O(n)，其中n为输入数组nums的长度。这是因为代码中创建了一个大小为n的dp数组来存储以每个元素结尾的最长连续递增子序列的长度。

c++ 代码（动态规划代码）

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        if (nums.size() <= 1) return nums.size(); // 特判，如果nums长度为0或1，直接返回其长度
        
        vector<int> dp(nums.size(), 1); // 创建一个dp数组，用于存储以nums[i]结尾的最长连续递增子序列的长度，默认初始为1
        
        int ans = 0; // 初始化最长连续递增子序列的长度为0
        
        for (int i = 1; i < nums.size(); i++) // 遍历数组nums
        {
            if (nums[i] > nums[i - 1]) // 如果nums[i]大于nums[i-1]，则可以将nums[i]加入到以nums[i-1]结尾的最长连续递增子序列中
                dp[i] = dp[i - 1] + 1; // 更新以nums[i]结尾的最长连续递增子序列的长度
            
            if (ans < dp[i]) // 更新最长连续递增子序列的长度
                ans = dp[i];
        }
        
        return ans; // 返回最长连续递增子序列的长度
    }
};

c++代码（贪心）

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        if (nums.size() == 0) return 0; // 如果数组为空，则最长连续递增子序列长度为0
        int result = 1; // 连续子序列最少也是1
        int count = 1; // 记录当前连续递增子序列的长度
        for (int i = 1; i < nums.size(); i++) {
            if (nums[i] > nums[i - 1]) { // 如果当前元素大于前一个元素，表示仍然在连续递增子序列中
                count++;
            } else { // 如果不连续了，需要重新计算连续递增子序列的长度
                count = 1;
            }
            if (count > result) result = count; // 更新最长连续递增子序列的长度
        }
        return result; // 返回最长连续递增子序列的长度
    }
};

Java代码

public static int findLengthOfLCIS(int[] nums) {
    int[] dp = new int[nums.length]; // 创建一个大小为nums.length的数组dp，用于存储以nums[i]结尾的最长连续递增子序列的长度，默认初始值为1
    for (int i = 0; i < dp.length; i++) {
        dp[i] = 1; // 初始化dp数组的每个元素为1
    }
    int res = 1; // 初始化最长连续递增子序列的长度为1
    for (int i = 0; i < nums.length - 1; i++) { // 遍历数组nums，从第一个元素到倒数第二个元素
        if (nums[i + 1] > nums[i]) { // 如果nums[i+1]大于nums[i]，则可以将nums[i+1]加入到以nums[i]结尾的最长连续递增子序列中
            dp[i + 1] = dp[i] + 1; // 更新以nums[i+1]结尾的最长连续递增子序列的长度
        }
        res = res > dp[i + 1] ? res : dp[i + 1]; // 更新最长连续递增子序列的长度
    }
    return res; // 返回最长连续递增子序列的长度
}

觉得有用的话可以点点赞，支持一下。

如果愿意的话关注一下。会对你有更多的帮助。

每天都会不定时更新哦  >人<  。