点赞👍👍收藏🌟🌟关注💖💖
你的支持是对我最大的鼓励，我们一起努力吧!😃😃

1.最长递增子序列

题目链接： 300. 最长递增子序列

题目分析：

听懂这道题一定要把动态规划里面这道题解法搞清楚，我们的贪心策略其实是基于动态规划的解法，就是动态规划的解法的过程中发现可以用贪心优化的地方。还有优选算法那里的二分查找搞清楚。我们这里的贪心策略是要用这两个东西。

算法原理：

1. 回顾 dp 的解法

状态表示：dp[i] 表示：以 i 位置的元素为结尾的所有子序列中， 最长递增子序列的长度

状态转移方程：dp[i] = max(dp[j] + 1) (j < i && nums[j] < nums[i])

更新dp[i] 的值，就是拿着nums[i] 去前面找，当找到一个位置发现这个位置的值，nums[j] < nums[i] 说明 i 可以拼在 j 的后面，此时就用这个dp[j]也就是以 j 位置为结尾的最长递增子序列的长度 然后 + 1 更新 dp[i] 的值。当把前面都找完此时dp[i]的值就是以 i 位置的元素为结尾的所有子序列中， 最长递增子序列的长度。

最核心的操作中，我们会发现一个性质：我们在考虑最长递增子序列的 “长度” 的时候，并不关心你这个序列长什么样子，我们仅关心你的 “最后一个元素” 是谁。

2. 贪心优化

接下来我们用一个例子模拟一下贪心过程

从前到后扫描每一个元素，当扫描第一个位置的元素时候其实我们得到一个长度为1 的序列长什么样子。(但是我们只关心递增子序列长度为x中最后一个元素，并不关心序列长什么样子)，这一点在上面已经说过了。

扫描到3的时候发现，3是接不到7后面，所以3这个元素单独形成一个长度为1的序列，现在又找到一个长度为1的序列最后一个元素是3。此时贪心策略就来了，当我发现长度为1递增子序列有两个的时候，较大的就没有必要存了。

原因就是，所有能接到7后面的数，铁定能接到3这个数的后面，所以我们不需要存较大的7，仅需存较小的3就可以判断后面的数是否能拼到长度为1的序列后面。

这里就是我们的第一个贪心策略，存最后一个元素的时候，仅需存储最小值。

扫描8的时候，此时第二个贪心策略来了。我们其实有两种策略，第一种让8单独形成一个长度为1的序列，第二种要么让8拼到3的后面形成一个长度为2的序列。此时我们贪心选择第二种策略。因为要找最长递增子序列。

扫描到4，发现4能放到长度为1的3后面，但是不放，太浪费了，所以往下放，发现4可以自己形成一个长度为2，但是发现4小于8，所以贪心把8干掉，把4放好。

上面的过程就是，发现4能放到长度为1的3后面，但是不放。往下放，发现4能不能放到8后面，就把4放到这里，同时利用第二个贪心策略只存最小值的时候，把8干掉，4留下。

扫描到7，也是一样，7能拼到3后面就不放，7能拼到4后面也不放，所以7形成一个长度为3的序列

扫描到2，发现2拼不到3后面，只能把2放到长度为1，但是2比3小，能拼接到3后面一定能拼接到2后面，所以3干掉，保留2

扫描到14，发现能拼接到2，4，7后面但是都不放，所以14单独形成一个长度为4的序列

扫描到13，发现能拼接到2，4，7后面但是不放，不能放14后面，就放14后面，同时13比14小，14干掉，13保留

当整个数组扫描完，我们发现长度仅从1更新到4，所以最长递增子序列的长度就是4。

虽然这里拼接的序列并不是最终的序列，但是能统计到4，就是我们的最长递增子序列的长度。

这里我们总结一下贪心策略：

我们的贪心策略就体现在两个地方：存什么，存哪里

这里的贪心策略的提出就是交换论证法的思想，比如能拼接7的后面的数，铁定能拼接到3的后面，这不就是交换论证吗。

这里已经说明为什么贪心策略是对的，但是我们分析一下贪心的时间复杂度，存什么肯定是拿一个数组去存，下标为0存长度为1的最小值、下标为1存长度为2的最小值…，最耗时的就是存哪里，如果是来了一个数从前往后扫描比较时间复杂度是O(n)，那整体时间复杂度还是O(N^2)，这个好像和动规是一样的。那还贪心什么呢？比动规还难理解。

我们还可以发现，我们贪心得到的数组，其实还有优化的地方

3. 利用二分优化

我们发现存长度为x的最小值数组里面的值是递增有序的。此时我们在找存哪里插入位置的时候，可以用二分快速找到插入位置。

假设来一个x，我们要找的是所有大于等于x的最小值，右边都是大于等于x，左边是小于x，这就有了二段性。就可以用二分查找了。

证明数组是递增的。

直接证明：

第一个元素来了直接就是一个点，第二个元素来发现能拼在第一个元素后面所以重新开一个点，如果不能放就把这个元素覆盖到原始元素，这里有个不等关系，这个元素大于前一个元素，小于后一个元素。递增是不会改变的。

回归一下二分，定义一个left，right，mid，如果mid落在左边 left = mid + 1，如果mid落在右边有可能是结果 right = mid，等到循环解决，left或者right就是要插入的位置。

这里有个细节问题，再用二分的时候要考虑边界情况，因为我们要找的是大于等于nums[i]的最小值的位置，left和right其实是在这个数组中找，有没有这个数比这个数组中所有数都大，那此时应该是数组重新开一个空间，放在这个新开位置里，所以二分之前先判断 nums[i] > ret.back()，此时不用二分，直接放在数组后一个位置。否则在二分寻找插入位置。

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 < nums.size(); ++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) / 2;
                    if(ret[mid] < nums[i])
                        left = mid + 1;
                    else
                        right = mid;                        
                }
                ret[left] = nums[i];
            }
        }
        return ret.size();

    }
};

2.递增的三元子序列

题目链接：334. 递增的三元子序列

题目分析：

上面是要找到最长的递增子序列，这里仅需判断一下是否存在长度为3的递增子序列就可以了。

算法原理：

最长递增子序列有两种解法，这里也是有两种解法。

解法一：动规

利用 dp 找到数组中最长递增子序列的长度，判断是否大于等于 3 即可

时间复杂度 O(n^2)，会超时的。

解法二：贪心

因为这里我们仅需判断递增子序列长度是否等于3就可以了，因此可以不用二分也是非常快的。我们只要判断长度3这里是否有值就可以了，不需要关心里面是否最小也不需要关心长度4、5、6…的情况。任意来一个x，我们仅需要比较2次，最差每个数都比较2次，总体就是2n，时间复杂度就是O(n)，即使用二分也是O(log₂n)，差别不是很大。

那如何实现呢？
第一种：可以像最长递增子序列一样用数组
第二种：仅需两个变量a，b

a代表长度为1最小元素，b代表长度为2最小元素。
a初始为第一个元素，b初始为INT_MAX

来了一个数，先和b比较，一旦这个数大于b，说明可以放在长度3，直接返回true，如果不大于b说明是小于等于b，然后和a做比较，如果大于a说明可以放在b的位置，如果小于a说明可以放在a的位置。

class Solution {
public:
    bool increasingTriplet(vector<int>& nums) {

        int n = nums.size();
        int a = nums[0], b = INT_MAX;
        for(int i = 1; i < n; ++i)
        {
            if(nums[i] > b) return true;
            else if(nums[i] > a) b = nums[i];
            else a = nums[i];
        }
        return false;
        
        // 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];
        //     }
        // }
        // return ret.size() >= 3 ? true : false;

    }
};

3.最长连续递增序列

题目链接： 674. 最长连续递增序列

题目分析：

给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。如果是连续的子序列其实就是子数组了，那这道题其实就变得简单了。

算法原理：

我们可以用暴力的思路来解决。用指针i固定一个数，然后再来一个指针j，让这个指针j向后移动，去找以i位置为起点的最长连续的递增序列。

怎么找？很简单，只要j位置元素比j-1位置元素大，j就往后移动，当j位置元素比j-1位置元素小就结束，此时就找完了以i位置为起点的最长连续的递增序列。

注意此时指针i并不直接向后移动1位，这里有一个小贪心，我们会发现 固定 i 位置然后找到这一段已经是递增并且是最长的，此时如果让i向后移动1位，那找的还是之前 i 位置的递增连续子序列，并且比之前的短，因此 i 移动到 j 位置，以 j 位起点在往后找。

所以我们这里的策略：贪心 + 双指针

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {

        int n = nums.size();
        int i = 0, j = 0, ret = 0;
        while(i < n)
        {
            j = i + 1;
            // 找到递增区间的末端
            while(j < n && nums[j] > nums[j - 1]) ++j;
            ret = max(ret, j - i);
            i = j;// 直接在循环中更新下⼀个位置的起点
        }
        return ret;

    }
};