[力扣c++实现] 300. 最长递增子序列

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

提示：

1 <= nums.length <= 2500
-104 <= nums[i] <= 104

进阶：

你能将算法的时间复杂度降低到 O(n log(n)) 吗?

1.c++

#include <vector>
#include <map>
#include <algorithm>
#include <iostream>

class Solution {
public:
    void getMoreThanCurrentSeqSeqArray(const std::vector<int>& nums, const std::vector<int>& seqArray,int pos, std::map<int,std::vector<int>>& morethanMeSeq)
    {
        int i = pos + 1;
        for (;i < (int)seqArray.size();++i)
        {
            if (seqArray[i] > seqArray[pos] && nums[seqArray[i]] > nums[seqArray[pos]])//寻找自己右边seq
            {
                morethanMeSeq[seqArray[pos]].push_back(seqArray[i]);
            }
        }
    }

    void getNodeLenth(int& maxLenth,int nextSeq, int&num, std::map<int,std::vector<int>>& morethanMeSeq)
    {
        auto& seqArray = morethanMeSeq[nextSeq];
        for (auto n : seqArray)
        {
            num += 1;
            if (maxLenth < num)
                maxLenth = num;
            getNodeLenth(maxLenth,n,num,morethanMeSeq);
            num -= 1;
        }
    }

    int lengthOfLIS(std::vector<int>& nums) {
        std::vector<std::pair<int,int>> value2Seq;
        int size = (int)nums.size();
        for (int i = 0;i < size; ++i)
            value2Seq.push_back({nums[i],i});
        if (value2Seq.size() == 0)
            return 0;
        std::sort(value2Seq.begin(),value2Seq.end(),[&](const auto v2s1,const auto&v2s2){
            return v2s1.first < v2s2.first;
        });

        std::vector<int> seqArray;
        for (const auto& v2s : value2Seq)
            seqArray.push_back(v2s.second);
        
        std::map<int,std::vector<int>> morethanMeSeq;
        for (int i = 0; i < seqArray.size(); ++i)
        {
            morethanMeSeq[seqArray[i]] = {};
            getMoreThanCurrentSeqSeqArray(nums, seqArray, i, morethanMeSeq);
        }

        /* //每个位置所对应的比它所在的元素大的元素的位置集合
            0|{7,6}
            1|{7,6}      
            2|{4,3,5,7,6}
            3|{5,7,6}
            4|{5,7,6}
            5|{7,6}
            6|{}
            7|{}
        */
        #if 0
        int maxRet = 1;
        for (auto& [val,seq]: value2Seq)
        {
            int num = 1;
            getNodeLenth(maxRet,seq,num,morethanMeSeq);
        }
        return maxRet == INT32_MIN?0:maxRet;
        #endif

        //动态规划版本 //通过
        std::vector<std::pair<int,std::vector<int>>> seqWithMoreThanSeq;
        for(auto& [seq,seqVec] : morethanMeSeq)
        {
            seqWithMoreThanSeq.push_back({seq,seqVec});
        }
        std::sort(seqWithMoreThanSeq.begin(),seqWithMoreThanSeq.end(),[&](const auto& vec1,const auto& vec2){
            return vec1.second.size() < vec2.second.size();
        });//为什么要排序,为了能够从已知求未知(即动态规划的核心)

        std::vector<int> dynamicVal(size,1);
        for (auto& [seq,vec] : seqWithMoreThanSeq)
        {
            dynamicVal[seq] = 1 + maxSeqFromArray(vec,dynamicVal);
        }

        return (int)*std::max_element(dynamicVal.begin(),dynamicVal.end());
    }

    int maxSeqFromArray(std::vector<int>& seqVec,const std::vector<int>& dynamicVal)
    {
        int maxSeq = 0;
        for (auto seq: seqVec)
        {
            if (maxSeq < dynamicVal[seq])
            {
                maxSeq = dynamicVal[seq];
            }
        }
        return maxSeq;
    }
};

//[-2,-1,1,2,3]

int main()
{
    Solution slu;
    std::vector<int> nums = {-2,-1,1,2,3,-6,8,0,6,8};
    //std::vector<int> nums = {10,9,2,5,3,7,101,18};
    //std::vector<int> nums = {7,7,7,7,7,7,7};
    std::cout << slu.lengthOfLIS(nums) << std::endl;
}

2.解法