LeetCode刷题--- 最长递增子序列的个数

个人主页：元清加油_【C++】,【C语言】,【数据结构与算法】-CSDN博客

个人专栏

力扣递归题

 http://t.csdnimg.cn/yUl2I

【C++】    

​​​​​​http://t.csdnimg.cn/6AbpV

数据结构

 ​​​http://t.csdnimg.cn/hKh2l

---

前言：这个专栏主要讲述动态规划算法，所以下面题目主要也是这些算法做的  

我讲述题目会把讲解部分分为3个部分：
1、题目解析

2、算法原理思路讲解

3、代码实现

---

最长递增子序列的个数

题目链接：最长递增子序列的个数

题目

给定一个未排序的整数数组 nums ， 返回最长递增子序列的个数 。

注意 这个数列必须是 严格 递增的。

示例 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。

提示: 

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

---

解法

算法原理解析

我们这题使用动态规划，我们做这类题目可以分为以下五个步骤

1. 状态显示
2. 状态转移方程
3. 初始化（防止填表时不越界）
4. 填表顺序
5. 返回值

• 状态显示

先尝试定义⼀个状态：以 i 为结尾的最⻓递增⼦序列的「个数」。那么问题就来了，我们都不知道以 i 为结尾的最⻓递增⼦序列的「长度」是多少，我怎么知道最⻓递增⼦序列的个数呢？

因此，我们解决这个问题需要两个状态，⼀个是「⻓度」，⼀个是「个数」：

1. len[i] 表示：以 i 为结尾的最长递增子序列的长度。
2. count[i] 表示：以 i 为结尾的最长递增子序列的个数。

• 状态转移方程

求个数之前，我们得先知道⻓度，因此先看 len[i] ：

1. 在求 i 结尾的最⻓递增序列的⻓度时，我们已经知道 [0, i - 1] 区间上的 len[j] 信息，⽤ j 表示 [0, i - 1] 区间上的下标；
2. 我们需要的是递增序列，因此 [0, i - 1] 区间上的 nums[j] 只要能和 nums[i]构成上升序列，那么就可以更新 len[i] 的值，此时最长长度为 len[j] + 1 ；
3. 我们要的是 [0, i - 1] 区间上所有情况下的最大值。

综上所述，对于 len[i] ，我们可以得到状态转移⽅程为：

        len[i] = len[j] + 1，其中 0 <= j < i ，并且 nums[j] < nums[i] && len[j] + 1 > len[i]。

在知道每⼀个位置结尾的最长递增⼦序列的长度时，我们来看看能否得到 count[i] ：

1. 我们此时已经知道 len[i] 的信息，还知道 [0, i - 1] 区间上的 count[j] 信息，⽤ j 表⽰ [0, i - 1] 区间上的下标；
2. 我们可以再遍历⼀遍 [0, i - 1] 区间上的所有元素，只要能够构成上升序列，并且上升序列的⻓度等于 dp[i] ，那么我们就把 count[i] 加上 count[j] 的值。这样循 环⼀遍之后， count[i] 存的就是我们想要的值。

综上所述，对于 count[i] ，我们可以得到状态转移⽅程为：

1. count[i] += count[j] ，其中 0 <= j < i ，并且 nums[j] < nums[i] && len[j] + 1 == len[i] 。
2. count[i] = count[j] ，其中 0 <= j < i ，并且 nums[j] < nums[i] && len[j] + 1 > len[i] 。

• 初始化（防止填表时不越界）

1. 对于 len[i] ，所有元素自己就能构成⼀个上升序列，直接全部初始化为 1 ；
2. 对于 count[i] ，全部初始化为 1.

• 填表顺序

根据「状态转移⽅程」易得，填表顺序为「从左往右」。

• 返回值

⽤ ansl en 表⽰最终的最⻓递增⼦序列的⻓度。

根据题⽬要求，我们应该返回所有⻓度等于 ansl en 的子序列的个数。

---

代码实现

class Solution {
public:
    int findNumberOfLIS(vector<int>& nums) 
    {
        int n = nums.size();

        // 状态显示
        vector<int> len(n + 1, 1);				// 以i为结尾，最长的递增子序列的长度
        vector<int> count(n + 1, 1);			// 以i为结尾，最长的递增子序列的个数
        
        int anslen = 1;
        int	anscount = 1;						// 记录最终结果

        for (int i = 1; i < n; i++)
        {
            for (int j = 0; j < i; j++)
            {
                if (nums[j] < nums[i])
                {
                    if (len[j] + 1 == len[i])
                    {
                        count[i] += count[j];

                    }
                    else if (len[j] + 1 > len[i]) // 重新计数
                    {
                        len[i] = len[j] + 1;
                        count[i] = count[j];
                    }
                }
            }
            if (anslen == len[i])
            {
                anscount += count[i];
            }
            else if (anslen < len[i])
            {
                // 重新计数
                anslen = len[i];
                anscount = count[i];
            }
        }

        return anscount;
    }
};