目录
题目一：最长递增子序列
给你一个整数数组 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
首先说明本题是子序列，也就是在一个数组中可以跳过某一个元素，组成序列，可以不连续
而子数组则是要求连续的
并且本题要求是找到严格递增子序列，也就是不能有重复元素
①状态表示
②状态转移方程
此时分为两类，i位置单独作为一个子序列，或是i位置跟在前面的某一个递增子序列的后面，作为一个子序列
也就是长度大于1时，此时的dp[i] = dp[j] + 1，但是dp[j] 时会变的，所以是 max(dp[j] + 1)，j的取值范围是 0 ~ i - 1，所以这里是在 0 ~ i - 1 这个范围内找一个最大值
求dp[j] 的最大值
③初始化
因为数组只要有值，那么最小长度就是1，所以可以将dp表初始化为1，这样就不需要考虑第一种长度为1的情况了
④填表顺序
从左往右
⑤返回值
因为 dp[i] 表示，以 i 位置为结尾的最长子序列，而最长子序列可能是任意位置结尾，所以需要取dp表的最大值返回
代码如下：
class Solution
{
public:
int lengthOfLIS(vector<int>& nums)
{
int n = nums.size(), ret = 1;
vector<int> dp(n, 1);
for(int i = 1; i < n; i++)
{
// 0 ~ i - 1范围内找最大值
for(int j = 0; j < i; j++)
if(nums[j] < nums[i])
dp[i] = max(dp[j] + 1, dp[i]);
// 每得到一个dp[i]，得到最大值给ret
ret = max(ret, dp[i]);
}
return ret;
}
};题目二：摆动序列
如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为 摆动序列 。第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。
-
例如，
[1, 7, 4, 9, 2, 5]是一个 摆动序列 ，因为差值(6, -3, 5, -7, 3)是正负交替出现的。 - 相反，
[1, 4, 7, 2, 5]和[1, 7, 4, 5, 5]不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。
子序列 可以通过从原始序列中删除一些（也可以不删除）元素来获得，剩下的元素保持其原始顺序。
给你一个整数数组 nums ，返回 nums 中作为 摆动序列 的 最长子序列的长度 。
示例 1：
输入：nums = [1,7,4,9,2,5] 输出：6 解释：整个序列均为摆动序列，各元素之间的差值为 (6, -3, 5, -7, 3) 。
示例 2：
输入：nums = [1,17,5,10,13,15,10,5,16,8] 输出：7 解释：这个序列包含几个长度为 7 摆动序列。 其中一个是 [1, 17, 10, 13, 10, 16, 8] ，各元素之间的差值为 (16, -7, 3, -3, 6, -8) 。
示例 3：
输入：nums = [1,2,3,4,5,6,7,8,9] 输出：2
摆动序列其实就是一上一下，前一个大后一个就小，前一个小后一个就大这样的规律
①状态表示
因为摆动序列是一上一下的，所以以 i 位置为结尾时，会有两种情况：
所以分为两种状态表示
②状态转移方程
同样需要写两个状态转移方程
f[i]和g[i]都分为两类，分别是长度等于1和长度大于1
f[i](上升)：
长度等于1：1
长度大于1：因为是f[i]是以i位置为结尾上升趋势，所以它的前一个位置 j 就需要小于 i 位置, j < i
所以就是求 j 位置下降趋势的最大子序列，也就是 g[j]，整体的最大子序列就是g[j] + 1，又因为求的是最大的，每个位置都有可能是最大的，所以是 max(g[j] + 1, f[i])
g[i](下降)：与f[i]一样，不详细讲解了
长度等于1：1
长度大于1：max(f[j] + 1, g[i])
③初始化
因为题目所给的数组最少有一个元素，而一个元素也算摆动序列，所以最少的长度也会是1
因为初始化直接将所有位置全部初始化为1即可，此时长度为1的情况就不需要考虑，只需要考虑长度大于1的情况
④填表顺序
因为 i 位置需要 j 位置，而 j 位置时 i 位置之前的位置，所以填表顺序是：
从左往右，两个表一起填
⑤返回值
返回值就是 f 和 g 两个表中的最大值
代码如下：
class Solution
{
public:
int wiggleMaxLength(vector<int>& nums)
{
int n = nums.size(), ret = 1;
vector<int> f(n, 1), g(n, 1);
for(int i = 1; i < n; i++)
{
for(int j = 0; j < i; j++)
{
// 上升趋势：更新f[i]
if(nums[j] < nums[i])
f[i] = max(g[j] + 1, f[i]);
// 下降趋势：更新g[i]
else if(nums[j] > nums[i])
g[i] = max(f[j] + 1, g[i]);
}
// 每次都取f[i]和g[i]的最大值
ret = max(ret, max(f[i], g[i]));
}
return ret;
}
};题目三：最长递增子序列的个数
给定一个未排序的整数数组 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。
本题也是求最长递增子序列，但是本题是求最长递增子序列的个数有多少个
下面说一个与本题有关的小贪心算法，在数组中找出最大值出现的次数，要求只遍历一遍：
此时只需创建两个变量，一个maxval，一个count，初始遍历数组时，maxval = nums[0]，count=1
此时遍历数组只有三种结果：
①nums[i] < maxval：直接忽略，因为此时比maxval小，不是最大值
②nums[i] == maxval：count++
③nums[i] > maxval：重置maxval = nums[i]，也重置 count = 1，重新计数
此时遍历结束就能够做到，maxval时最大值，count是最大值出现的次数
同样分为下面5步：
①状态表示
按照之前的经验，dp表含义如下：
但是此题连最长的递增子序列的个数都不知道，无法统计，所以需要两个dp表，一个统计长度，一个统计个数：
②状态转移方程
上面的 len 表的状态转移方程就是求最长递增子序列的方法
len[i] = max(len[j] + 1, len[i]);
因为上述的小算法提到了，计算最长的长度时，还需要同时统计个数，所以count也需要同时更新
此时的count[i]也分为三种情况：
在 0 ~ i-1 区间中，如果 nums[j] < nums[i]，分为三种情况：
①len[j] + 1 == len[i]：此时 count[i] += count[j]
②len[j] + 1 < len[i]：此时无视
③len[j] + 1 > len[i]：此时更新len[i] = len[j] + 1，count[i] = count[j]
③初始化
初始化就将len和count表的所有值更新为1即可，因为最小就是1
④填表顺序
从左往右填表
⑤返回值
这里的返回值同样是使用上面说到了的小贪心算法，一次遍历既找到最大值，又统计了最大值出现的次数
代码如下：
class Solution
{
public:
int findNumberOfLIS(vector<int>& nums)
{
int n = nums.size();
vector<int> len(n, 1), count(n, 1);
int retlen = 1, retcount = 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(retlen == len[i]) retcount += count[i];
else if(retlen < len[i])
{
retlen = len[i];
retcount = count[i];
}
}
return retcount;
}
};题目四：最长数对链
给你一个由 n 个数对组成的数对数组 pairs ，其中 pairs[i] = [lefti, righti] 且 lefti < righti 。
现在，我们定义一种 跟随 关系，当且仅当 b < c 时，数对 p2 = [c, d] 才可以跟在 p1 = [a, b] 后面。我们用这种形式来构造 数对链 。
找出并返回能够形成的 最长数对链的长度 。
你不需要用到所有的数对，你可以以任何顺序选择其中的一些数对来构造。
示例 1：
输入：pairs = [[1,2], [2,3], [3,4]] 输出：2 解释：最长的数对链是 [1,2] -> [3,4] 。
示例 2：
输入：pairs = [[1,2],[7,8],[4,5]] 输出：3 解释：最长的数对链是 [1,2] -> [4,5] -> [7,8] 。
也就是 [1, 2] 后面只能跟比 2 大的数对，例如 [3, 4]，如果是 [2, 3]就不行，因为 2 不大于2
此题在做之前，需要将数对按照第一个元素排序，这样才能保证在选择以某一个数对为结尾时，只会在该数对的前面选择元素，这样就可以保证填dp表时的顺序问题了
①状态表示
②状态转移方程
同样是分为两类，长度为1，长度大于1
长度为1 ：dp[i] = 1
长度大于1：p[j][1] < p[i][0] 才能满足要求，此时dp[i] = dp[j] + 1，又因为是求最长的数对链，所以
dp[i] = max(dp[j] + 1, dp[i]);
③初始化
dp表中元素全部初始化为1，此时只需要考虑长度大于1的情况，长度等于1的情况初始化已经完成了
④填表顺序
因为 j 的取值范围是 0 ~ i - 1，是小于 i 的，所以填表顺序是从左往右
⑤返回值
返回dp表的最大值,因为不能确定以哪个位置结尾的数对链长度最大
代码如下：
class Solution
{
public:
int findLongestChain(vector<vector<int>>& pairs)
{
// 预处理
sort(pairs.begin(), pairs.end());
int n = pairs.size(), ret = 1;
vector<int> dp(n, 1);
for(int i = 1; i < n; i++)
{
for(int j = 0; j < i; j++)
{
if(pairs[j][1] < pairs[i][0])
{
dp[i] = max(dp[j] + 1, dp[i]);
}
}
ret = max(ret, dp[i]);
}
return ret;
}
};题目五：最长定差子序列
给你一个整数数组 arr 和一个整数 difference，请你找出并返回 arr 中最长等差子序列的长度，该子序列中相邻元素之间的差等于 difference 。
子序列 是指在不改变其余元素顺序的情况下，通过删除一些元素或不删除任何元素而从 arr 派生出来的序列。
示例 1：
输入：arr = [1,2,3,4], difference = 1 输出：4 解释：最长的等差子序列是 [1,2,3,4]。
示例 2：
输入：arr = [1,3,5,7], difference = 1 输出：1 解释：最长的等差子序列是任意单个元素。
示例 3：
输入：arr = [1,5,7,8,5,3,4,2,1], difference = -2 输出：4 解释：最长的等差子序列是 [7,5,3,1]。
这道题与前面题的区别就是：给定了等差序列的差是多少了，所以如果知道 i 位置的元素，那么根据等差，就能够计算出来 j 位置的元素的值是多少
①状态表示
②状态转移方程
③初始化
④填表顺序
⑤返回值
题目六：最长斐波那契子序列的长度
如果序列 X_1, X_2, ..., X_n 满足下列条件，就说它是 斐波那契式 的：
n >= 3- 对于所有
i + 2 <= n，都有X_i + X_{i+1} = X_{i+2}
给定一个严格递增的正整数数组形成序列 arr ，找到 arr 中最长的斐波那契式的子序列的长度。如果一个不存在，返回 0 。
（回想一下，子序列是从原序列 arr 中派生出来的，它从 arr 中删掉任意数量的元素（也可以不删），而不改变其余元素的顺序。例如， [3, 5, 8] 是 [3, 4, 5, 6, 7, 8] 的一个子序列）
示例 1：
输入: arr = [1,2,3,4,5,6,7,8]
输出: 5
解释: 最长的斐波那契式子序列为 [1,2,3,5,8] 。
示例 2：
输入: arr = [1,3,7,11,12,14,18]
输出: 3
解释: 最长的斐波那契式子序列有 [1,11,12]、[3,11,14] 以及 [7,11,18] 。
题目七：最长等差数列
给你一个整数数组 nums，返回 nums 中最长等差子序列的长度。
回想一下，nums 的子序列是一个列表 nums[i1], nums[i2], ..., nums[ik] ，且 0 <= i1 < i2 < ... < ik <= nums.length - 1。并且如果 seq[i+1] - seq[i]( 0 <= i < seq.length - 1) 的值都相同，那么序列 seq 是等差的。
示例 1：
输入：nums = [3,6,9,12] 输出：4 解释： 整个数组是公差为 3 的等差数列。
示例 2：
输入：nums = [9,4,7,2,10] 输出：3 解释： 最长的等差子序列是 [4,7,10]。
示例 3：
输入：nums = [20,1,15,3,10,5,8] 输出：4 解释： 最长的等差子序列是 [20,15,10,5]。
题目八：等差序列划分II
困难
动态规划：子序列问题到此结束