点赞👍👍收藏🌟🌟关注💖💖
你的支持是对我最大的鼓励，我们一起努力吧!😃😃
1.最长递增子序列
题目链接： 300. 最长递增子序列
题目分析：
什么是子序列？
子序列可以是数组中不连续的部分也可以是连续的部分，但是选择的数必须和原数组保持相对顺序不变。
给你一个整数数组 nums ，找到其中最长严格递增子序列的长度，严格递增就是一直往上，没有水平。
算法原理：
1.状态表示
经验 + 题目要求
以 i 位置为结尾，巴拉巴拉
题目要求找到其中最长严格递增子序列的长度，首先 以 i 位置元素为结尾要是子序列，子序列还要是严格递增，并且还是最长。因此
dp[i] 表示：以 i 位置元素为结尾的所有子序列中，最长递增子序列的长度
2.状态转移方程
dp[i] 表示：以 i 位置元素为结尾的所有子序列中，最长递增子序列的长度，可以先想一下，以 i 位置元素为结尾的所有子序列可以分几类：
一是，i 位置元素本身就是子序列
二是，i 位置元素跟在前面位置元素( 0 <= j <= i - 1)的后面构成子序列
因此状态转移方程可以分成两类情况讨论
长度为1，递增子序列的长度就是1
长度大于1，在 0 <= j <= i -1 区间， 要的是严格递增的子序列，因此必须要满足 nums[j] < nums[i] 前提下，我们要的是最长递增子序列，那 j 位置本身要是一个最长递增子序列，而dp[j] 表示：以 j 位置元素为结尾的所有子序列中，最长递增子序列的长度，在加上 i 位置就行了，注意 j 是变化的，我们要的是0 <= j <= i -1 区间内最长的递增子序列。因此我们要的是这个区间最大的 dp[j] +1
3.初始化
表里面的所有值初始为1，正好长度为1的不用去管了。
4.填表顺序
从左往右
5.返回值
dp[i] 表示：以 i 位置元素为结尾的所有子序列中，最长递增子序列的长度。因此返回的是dp表中的最大值
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
// 1.创建 dp 表
// 2.初始化
// 3.填表
// 4.返回值
int n = nums.size();
vector<int> dp(n, 1);
int ret = 1;
for(int i = 1; i < n; ++i)
{
for(int j = i - 1; j >= 0; --j)
{
if(nums[j] < nums[i])
{
dp[i] = max(dp[i], dp[j] + 1);
}
ret = max(ret, dp[i]);
}
}
return ret;
}
};
2.摆动序列
题目链接： 376. 摆动序列
题目分析：
给你一个整数数组 nums ，返回 nums 中作为 摆动序列 的 最长子序列的长度 。
上面摆动序列说了那么一大堆，其实摆动序列就是数组是一上一下的。
算法原理：
1.状态表示
经验 + 题目要求
以 i 位置为结尾，巴拉巴拉
题目要求找到其中 摆动序列 的 最长子序列的长度 ，首先要找到 以 i 位置元素为结尾要是子序列，子序列还要是 摆动序列，并且还是最长。因此
dp[i] 表示：以 i 位置元素为结尾的所有子序列中，最长摆动序列的长度。
但是先停一下，这里的可是摆动序列，最后一个位置有可能是呈现上升趋势或者是下降趋势，我们上面状态表示其实是有点粗糙的。
f[i] 表示，以 i 位置元素为结尾的所有子序列中，最后一个位置呈现 “上升” 趋势的最长摆动序列的长度
g[i] 表示，以 i 位置元素为结尾的所有子序列中，最后一个位置呈现 “下降” 趋势的最长摆动序列的长度
2.状态转移方程
f[i] 表示，以 i 位置元素为结尾的所有子序列中，最后一个位置呈现 “上升” 趋势的最长摆动序列的长度。可以先想一下，以 i 位置元素为结尾的所有子序列可以分几类：
一是，i 位置元素本身就是子序列
二是，i 位置元素跟在前面位置元素( 0 <= j <= i - 1)的后面构成子序列
因此状态转移方程可以分成两类情况讨论
长度为1，本身最后可以呈现上升趋势
长度大于1，在 0 <= j <= i -1 区间， 要的 i 位置最后呈现上升趋势的摆动序列，因此必须要满足 nums[j] < nums[i] 才能最后呈现上升趋势，我们要的是整体最长摆动序列的长度，那 j 位置要的是一个呈现下降趋势的最长摆动序列的长度，而这个就在g表中的g[j]，然后在加上 i 位置。注意 j 位置是变化的，我们要的是 0 <= j <= i -1 区间内最长的递增子序列。因此我们要的是这个区间最大的 g[j] +1
同理g表也是这样分析
3.初始化
f表和g表里面的所有值初始为1，正好长度为1的不用去管了。
4.填表顺序
从左往右，两个表一起填
5.返回值
最长摆动序列长度可能是数组中以任意一个位置元素为结尾并且最后呈现上升或者下降趋势，因此返回的就是两个表中的最大值
关于子序列写法非常固定，两层for循环
class Solution {
public:
int wiggleMaxLength(vector<int>& nums) {
// 1.创建 dp 表
// 2.初始化
// 3.填表
// 4.返回值
int n = nums.size();
vector<int> f(n, 1), g(n, 1);
int ret = 1;
for(int i = 1; i < n; ++i)
{
for(int j = i - 1; j >= 0; --j)
{
if(nums[j] < nums[i])
f[i] = max(f[i], g[j] + 1);
else if(nums[j] > nums[i])
g[i] = max(g[i], f[j] + 1);
}
ret = max(ret, max(f[i], g[i]));
}
return ret;
}
};
3.最长递增子序列的个数
题目链接： 673. 最长递增子序列的个数
题目分析：
前面一道题要求返回最长递增子序列长度，这里要求返回的是最长递增子序列的个数 。
在具体说算法原理之前，我们先来完成一个小demo：
在数组中找出最大值出现的次数，要求一次遍历解决问题。
其实我们可以定义两个遍历，maxval 记录最大值，count 记录最大值个数，初始maxval等于数组第一个元素，count为1。在遍历数组会遇到三种情况：
这样一次遍历就可以找到最大值出现的次数。
算法原理：
1.状态表示
经验 + 题目要求
题目要求找到最长递增子序列的个数，首先要找到 以 i 位置元素为结尾要是子序列，还要是递增的，因此
dp[i] 表示：以 i 位置元素为结尾的所有子序列中，最长递增子序列的个数。
但是这样给状态表示有些问题，你以 i 位置元素为结束的所有子序列中，最长递增子序列长度都不知道，你又如何知道最长递增子序列的个数的？
所以重新定义状态表示
len[i] 表示：以 i 位置元素为结尾的所有子序列中，最长递增子序列的 " 长度 "。
count[i] 表示：以 i 位置元素为结尾的所有子序列中，最长递增子序列的 " 个数 "。
2.状态转移方程
以 i 位置元素为结尾的所有子序列可以分几类：
一是，i 位置元素本身就是子序列
二是，i 位置元素跟在前面位置元素( 0 <= j <= i - 1)的后面构成子序列
下面将len表和count表放一起分析
长度为1，len[i] = count[i] = 1
长度大于1，因为是递增，所以要在在 0 <= j <= i - 1区间找 nums[j] < nums[i] 这是前提。根据找到的递增子序列的 " 长度 "，可以分为下面三种情况：
-
len[j] + 1 == len[i]，i 位置元素跟在 j位置元素的后面，并且此时最大子序列长度就是我跟在你后面的长度，这时候要统计出现的个数。统计到count里面，问题来了是要count[i] += 1 吗？并不是，i 位置元素跟在 j位置元素的后面形成的最大子序列长度，可能以 j 位置元素结尾能够形成好多种子序列，这个时候i跟在后面，是不是应该也是这么多种。比如是 j 位置元素结尾能够形成5种子序列后面跟在i也应该是5种，因此 count[i] += count[j]
-
len[j] + 1 < len[i] ，虽然 i 位置元素能跟在 j位置元素的后面形成递增子序列，但是跟着j后面的长度是小于最大长度的。直接无视
-
len[j] + 1 > len[i]，如果发现 i 位置元素跟在 j位置元素的后面形成递增子序长度会变长，那之前所做的count[i]根本不是最长子序列长度个数，我们要重新计数，并且要更新最大长度，len[i] = len[j] + 1，count[i]重新计算是让它等于1吗？并不是，i位置是跟着j位置后面形成的递增子序列，这个时候个数应该是以j位置为结尾的个数count[i] = count[j]
这里和小demo 大部分几乎思路相同
3.初始化
两个表都初始化为最差情况 1，
4.填表顺序
从左往右，两个表一起填
5.返回值
我们要返回的是所有最大子序列长度对应的个数，也就是所有最大子序列长度对应count都要加上。我们有两种策略：
第一种：第一次遍历找最大子序列长度，第二次遍历找最大子序列对应长度。
第二种：小demo哪里的思想。一次遍历找到最大值个数
class Solution {
public:
int findNumberOfLIS(vector<int>& nums) {
// 1.创建 dp 表
// 2.初始化
// 3.填表
// 4.返回值
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;
}
};
4.最长数对链
题目链接： 646. 最长数对链
题目分析：
给你一个由 n 个数对组成的数对数组 pairs ，其中 pairs[i] = [lefti, righti] 且 lefti < righti 。
现在，我们定义一种 跟随 关系，当且仅当 b < c 时，数对 p2 = [c, d] 才可以跟在 p1 = [a, b] 后面。我们用这种形式来构造 数对链 。也就是说两个数对之间必须构成严格递增关系，才能构造数对链。
找出并返回能够形成的 最长数对链的长度 。
你不需要用到所有的数对，你可以以任何顺序选择其中的一些数对来构造。
这道题意很简单，但是和我们前面做的题有不一样的地方是，我们之前做动规的题必须要保证填表是有序的，也就是说填当前位置的时候，之前所依赖的状态必须是已经计算过的了。比如说子数组和子序列，当我们以i位置元素为结尾的时候，然后都是往前去选。
但是我们这道题就如第二个例子，选[7,8]为结尾研究数对链的时候，它左边和右边都可以选，这样就不能保证填表顺序，填 i 位置的时候就不能更新dp[i]的值。
所以，动规之前，要预处理一下：按照第一个元素排序即可(升序)
虽然不能保证 i 位置元素能连在前面元素的后面，但是一定能保证连不到后面，数对链内部严格递增
算法原理：
接下来和最长递增子序列长度是一模一样的
1.状态表示
dp[i] 表示，以 i 位置元素为结尾的所有数对链，最长的数对链的长度
2.状态转移方程
3.初始化
dp表中元素都初始化为1，这样就不要考虑长度为1的情况了。
4.填表顺序
从左往右
5.返回值
dp 表里面的最大值
class Solution {
public:
int findLongestChain(vector<vector<int>>& pairs) {
// 1.创建 dp 表
// 2.初始化
// 3.填表
// 4.返回值
//预处理
sort(pairs.begin(),pairs.end(),[](vector<int>& x,vector<int>&y){return x[0] < y[0];});
int n = pairs.size();
vector<int> dp(n, 1);// 创建 dp 表以及初始化
int ret = 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[i], dp[j] + 1);
}
}
ret = max(ret, dp[i]);
}
return ret;
}
};
扫一扫
3577
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
