---

前言

在本文章中，我们将要解决一下Leetcode中300. 最长递增子序列
在本道题目中，我们将会用动态规划和贪心两种策略分别来解决这道问题。

动态规划

题目解析

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

子序列：要求相对顺序一致，可以是不连续的
子数组： 顺序一致，必须是连续的

这也就说明了子数组其实是子序列的一部分
子序列可以有2^n个
子数组只有n^2个

注意：严格递增，不可以相等

算法原理

1.状态表示

列出dp表，dp表中值的含义是什么

以i位置为结尾,::::::

根据这道题，dp[ i ]:以i位置为结尾的，所有子序列中最长的递增子序列的个数

2.状态转移方程

dp[i]是什么

🌟i位置的值要末是自己组成一个最长递增子序列，要摸和前面的结合一起构成最长递增子序列。
🌟如果是自己构成子序列，dp[ i ]就是1；
🌟如果是与前面的结合，那就复杂了。
因为你不知道前面那麽多dp值，哪个和你结合才是最大的，同时要满足是递增的。
nums[ i ]可以跟在前面任何一个数后面形成子序列。
🌟我们在【0，i-1】区间内找到最大的dp值就可以,同时满足递增

dp[ i ]=max(dp[ j ]+1,dp[ i ])

3.初始化

我们可以全部初始化为0，在填表时，判断两种情况哪个大。
我们也可以按照最坏的情况填表，每个元素都是一个递增子序列，也就是初始化为1，
我们在进行填表时，就只需要关注第二种情况就可以了，自动进行判断。
填表时只需要从第二个位置开始就可以。

4.填表顺序

题目很明显就可以知道，从左向右进行填表

5.返回值是什么

我们再来看一下dp表的含义，所有子序列中最长的递增子序列的个数，所有我们需要在dp表中找最大值。
我们不用吧dp表填完之后，在进行寻找，我们可以一直填表一直寻找最长长度。

代码实现

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) 
    {
        int n=nums.size();
        vector<int>dp(n,1);
        int maxdp=1;
        for(int i=1;i<n;i++)
        {
            int j=0;
            for(j=0;j<i;j++)
            {
                if(nums[i]>nums[j])
                {
                    dp[i]=max(dp[i],dp[j]+1);
                }
            }
            maxdp=max(dp[i],maxdp);
        }
        return maxdp;
    }
};

时间复杂度为O（N^2），空间复杂度为O(N)

贪心

我们在介绍贪心解的时候，先回顾一下动态规划的解法。
我们在考虑最长递增子序列的长度的时候，我们并不关心这个序列是什么样子的，我们只关心最后一个元素是谁

算法原理

我们以【7，3，8，4，7，2，14，13】这组数据为例子分析一下。

🌟 我们遍历数组内容，首先是7，我们可以得到以下结论：长度为1的子序列为7
🌟 我们继续遍历，为3，3这个元素可以自己成为一个子序列，也可以与前面结合形成一个子序列，但是我们要求是递增的，这种条件并不满足，只能自己形成一个子序列。
🌟 这时，我们发现长度为1的子序列有两个了，一个为3，一个为7。贪心来了，贪心就是每一步都选择当前看起来最优的解法

所有可以跟在7，后边的元素都可以跟在3后边。

那么我们在继续便利的时候，就不需要管7这个元素了，只需要与3进行判断就可以。

🌟 继续遍历到8，8这个元素也有两种选择，自己形成一个子序列，或者与前面的结合形成一个子序列。贪心来了，贪心就是每一步都选择当前看起来最优的解法。

8是大于3的，说明可以跟在3后面，形成长度为2的子序列，这才是我们当前的最优解

🌟 继续遍历到4，4这个元素也有两种选择，自己形成一个子序列，或者与前面的结合形成一个子序列。
我们发现4这个元素是大于3这个元素元素的，所以可以跟在3后面，长度为2的最后一个元素为8，是不能跟在这个元素的后面的。这时长度为2的子序列就有两种，【3，8】，【3，4】.很显然【3，4】是更优的，为什莫呢？？？
因为所有可以跟在8后面的都可以跟在4后边。
所有我们之后进行判断的时候，就不用管8这个元素了。只需要关心4这个元素。
🌟 后面也是同样的道理…

我们直接来看遍历完样子

我们通过上帝视角发现这并不是我们子序列的样子，正常应该是【3，4，7，14】或者【3，4，7，13】。我们只要求长度就可以。

我们回想一下贪心的介绍，我们只介绍对的方法，至于为什莫对，我们不关心，当作经验吸收

我们再来总结一下贪心的地方

1.存什么：所有长度为x的递增子序列中，最后一个元素的最小值。
2.存哪里：所有大于等于nums[ i ]的最小值的位置。

分析一下时间复杂度：我们要遍历一遍，便利的同时遍历一下存放位置，时间复杂度为O(N^2);

二分优化

我们可以用二分算法优化时间复杂度。

因为我们存放的数据都是按照有序存放的，我们可以用二分查找算法快速找到对应的位置，就可以把使时间复杂度优化到O(N*logN)

代码实现

class Solution
{

public:
    int lengthOfLIS(vector<int>& nums)
    {
        int n = nums.size();
        vector<int> ret;
        ret.push_back(nums[0]);
        for (int i = 1; i < n; i++)
        {
            if (nums[i] > ret.back()) // 如果能接在最后⼀个元素后⾯，直接放
            {
                ret.push_back(nums[i]);
            }
            else
            {
                // ⼆分插⼊位置
                int left = 0, right = ret.size() - 1;
                while (left < right)
                {
                    int mid = (left + right) >> 1;
                    if (ret[mid] < nums[i]) left = mid + 1;
                    else right = mid;
                }
                ret[left] = nums[i]; // 放在 left 位置上
            }
        }
        return ret.size();
    }
};

总结

以上就是我们对Leetcode中最长递增子序列详细介绍，希望对大家的学习有所帮助，仅供参考 如有错误请大佬指点我会尽快去改正 欢迎大家来评论~~