LeetCode 673. 最长递增子序列的个数

本文介绍了LeetCode673题的解题思路和解决方案,主要讨论如何找到未排序整数数组中所有最长递增子序列的个数。通过动态规划和计数数组,可以有效地计算出结果。代码示例展示了如何实现这一算法,时间复杂度为O(n^2)。

LeetCode 673. 最长递增子序列的个数

题目描述

给定一个未排序的整数数组 nums , 返回最长递增子序列的个数 。
注意 这个数列必须是 严格 递增的。
  示例 1:
  输入: [1,3,5,4,7]
  输出: 2
解释: 有两个最长递增子序列,分别是 [1, 3, 4, 7] 和[1, 3, 5, 7]。

LeetCode 673. 最长递增子序列的个数
提示:


    1 <= nums.length <= 2000
    -106 <= nums[i] <= 106

一、解题关键词


二、解题报告

1.思路分析

2.时间复杂度

3.代码示例

public static int findNumberOfLIS(int[] nums) {
        int length = nums.length, maxLen = 0, ans = 0;
        int[] dp = new int[length];
        int[] count = new int[length];
        for (int i = 0; i < length; i++) {
            dp[i] = 1;
            count[i] = 1;
            for (int j = 0; j < i; ++j) {
                if (nums[i] > nums[j]) {
                    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 (dp[i] > maxLen) {
                maxLen = dp[i];
                ans = count[i];
            } else if (dp[i] == maxLen) {
                ans += count[i];
            }
        }
        return ans;
    }

2.知识点



总结

相同题目

xxx

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
发出的红包

打赏作者

大涛小先生

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值