LIS最长递增子序列的长度、个数

1、描述

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

来源：力扣（LeetCode）
链接
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2、关键字

dp

3、思路

dp,
初始化dp数组，
找固定状态
找状态跳转的关系
如果nums中当前值比nums数组中前一个值大，那么dp数组中的当前值是：dp数组中前一个值+1，和dp当前的初始值的最大值。

如果最后返回return dp[n-1];
就有情况是错的，所以找一个res一直保存最后的结果

4、notes

复习之前做过的题，思路

5、复杂度

时间：O（n方）
空间：O（N）dp数组长度

6、code

方法1，时间复杂度：平方：

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n=nums.size();  // 长度
        int res=0;  // 结果
        vector<int>dp(n,1);  // 初始化dp数组
        for(int i=0;i<n;i++){  // 遍历整个原数组
            for(int j=0;j<i;j++){  // 遍历当前元素之前的所有元素，
                if(nums[j]<nums[i]){
                    dp[i]=max(dp[j]+1,dp[i]);  // 更新dp数组
                }
            }
            res=max(res,dp[i]);  // 结果
        }
        return res;
    }
};

方法2：时间复杂度更低：

int lengthOfLIS(vector<int>& nums) {
    int len = 1, n = (int)nums.size();
    if (n == 0) {
        return 0;
    }
    vector<int> d(n + 1, 0);     d[len] = nums[0];
    for (int i = 1; i < n; ++i) {
        if (nums[i] > d[len] ) {
            d[++len] = nums[i];
        } else {
            int l = 1, r = len, pos = 0;
            while (l <= r) {
                int mid = (l + r) >> 1;
                if (d[mid] < nums[i]) {
                    pos = mid;
                    l = mid + 1;
                } else {
                    r = mid - 1;
                }
            }
            d[pos + 1] = nums[i];
        }
    }
    return len;
}

11 描述:最长递增子序列的个数

给定一个未排序的整数数组，找到最长递增子序列的个数。

示例 1:

输入: [1,3,5,4,7]
输出: 2
解释: 有两个最长递增子序列，分别是 [1, 3, 4, 7] 和[1, 3, 5, 7]。
示例 2:

输入: [2,2,2,2,2]
输出: 5
解释: 最长递增子序列的长度是1，并且存在5个子序列的长度为1，因此输出5。
注意: 给定的数组长度不超过 2000 并且结果一定是32位有符号整数。

来源：力扣（LeetCode）
链接：
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

33、思路

在原来的基础上，初始化dp数组的时候，做一个统计cnt，当前元素i,为最长递增子序列的最后一个元素时，最长递增子序列的个数。

55 、 复杂度

时间：O（N平方）
空间：O（N）

66、code

class Solution {
public:
    int findNumberOfLIS(vector<int>& nums) {
        int n = nums.size();
        int res = 1;
        int maxlen = 0; // 这里等于 1， 通不过
        vector<int>cnt(n, 1);
        vector<int>dp(n, 1);
        for(int i = 0; i < n; i++){  // i 得从 0 开始  从1开始不行      
            for(int j = 0; j < i; j++){
                if(nums[i] > nums[j]){
                    // 之前是：dp[i] = max(dp[i], dp[j] + 1);res = max(res,dp[i]);
                    // 现在需要统计个数，所以分开判断
                    if(dp[j] + 1 > dp[i]){   // 需要更新
                        dp[i] = dp[j] + 1;  // 需要 + 1 更新
                        cnt[i] = cnt[j];  // 重新计数
                    }
                    else if(dp[j] + 1 == dp[i]){ // 之前出现过一次了，
                        cnt[i] += cnt[j];
                    }
                }
            }
            if(dp[i] > maxlen){  // 更新最长
                maxlen = dp[i];
                res = cnt[i];
            }
            else if(dp[i] == maxlen){  // 之前出现过
                res += cnt[i];
            }
        }
        return res;
    }
    
};