Leetcode300 最长递增子序列

文章介绍了如何使用动态规划算法解决LeetCode上的一个问题,即在给定整数数组中找到最长的严格递增子序列的长度。通过遍历数组并更新dp数组来实现求解过程。

给你一个整数数组 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

解题思路:动态规划

力扣(LeetCode)官网 - 全球极客挚爱的技术成长平台 

代码如下:

class Solution {
    public int lengthOfLIS(int[] nums) {
        if(nums.length == 0){
            return 0;
        }
        int res = 0;
        int[] dp = new int[nums.length];
        Arrays.fill(dp,1);
        for(int i = 0; i < nums.length;i++){
            for(int j = 0; j < i; j++){
                if(nums[j] < nums[i]){
                    dp[i] = Math.max(dp[i],dp[j]+1);
                }
            }
            res = Math.max(res,dp[i]);
        }
        return res;
      
    }
}

LeetCode 673 题“最长递增子序列的个数”的动态规划解法及分析如下: ### 分析 - **定义状态**: - `dp[i]`:到`nums[i]`为止的最长递增子序列长度。 - `count[i]`:到`nums[i]`为止的最长递增子序列个数 [^2]。 - **初始化状态**: - `dp = [1] * n`:代表最长递增子序列的长度至少为 1。 - `count = [1] * n`:代表最长递增子序列的个数至少为 1 [^2]。 - **状态转移**: - 对于每个`i`,从 0 到`i - 1`遍历`j`,如果`nums[i] > nums[j]`,则有以下两种情况: - 若`dp[i] < dp[j] + 1`,说明找到了更长的递增子序列,更新`dp[i] = dp[j] + 1`,同时`count[i] = count[j]`。 - 若`dp[i] == dp[j] + 1`,说明找到了长度相同的递增子序列,更新`count[i] += count[j]` [^2]。 ### 代码实现 以下是用 C++ 实现的代码: ```cpp class Solution { public: int findNumberOfLIS(vector<int>& nums) { int n = nums.size(); if(n < 2) return n; vector<int> cnts(n, 1); vector<int> lens(n, 1); for(int i = 1; i < n; ++i) { for(int j = 0; j < i; ++j) { if(nums[i] > nums[j]) { // 代表第一次遇到最长子序列 if(lens[i] < lens[j] + 1) { lens[i] = lens[j] + 1; cnts[i] = cnts[j]; } // 代表已经遇到过最长子序列 else if(lens[i] == lens[j] + 1) { cnts[i] += cnts[j]; } } } } // 求最长递增子序列的长度 int maxLen = *max_element(lens.begin(), lens.end()); int maxCnt = 0; // 找到有最长长度的次数,将它们加起来 for(int i = 0; i < n; ++i) { if(maxLen == lens[i]) maxCnt += cnts[i]; } return maxCnt; } }; ``` 以下是用 C 语言实现的代码: ```c int findNumberOfLIS(int* nums, int numsSize) { if(numsSize == 0 || numsSize == 1) return numsSize; int *length = (int*)malloc(sizeof(int) * numsSize); int *count = (int*)malloc(sizeof(int) * numsSize); for(int i = 0; i < numsSize; i++) { count[i] = 1; // 以nums[i] 结尾得最长序列的个数 length[i] = 1; // 以nums[i]结尾的最长序列的长度 } int max = 1; for(int i = 1; i < numsSize; i++) { for(int j = 0; j < i; j++) { if(nums[i] > nums[j]) { if(length[i] < length[j] + 1) { length[i] = length[j] + 1; count[i] = count[j]; } else if(length[i] == length[j] + 1) { count[i] += count[j]; } } } max = max > length[i] ? max : length[i]; } int res = 0; for(int i = 0; i < numsSize; i++) { if(length[i] == max) res += count[i]; } return res; } ``` ### 复杂度分析 - **时间复杂度**:$O(n^2)$,其中`n`是数组的长度,因为有两层嵌套循环 [^3]。 - **空间复杂度**:$O(n)$,主要用于存储`dp`和`count`数组 [^3]。 ### 总结 动态规划是解决最长递增子序列个数问题的一种有效方法。通过定义合适的状态和状态转移方程,可以逐步计算出到每个位置为止的最长递增子序列长度和个数。最后,找出最长递增子序列的长度,并统计拥有该长度的子序列个数。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值