最长递增子序列---CPP实现

描述

给定数组 arr ，设长度为 n ，输出 arr 的最长递增子序列。（如果有多个答案，请输出其中 按数值(注：区别于按单个字符的ASCII码值)进行比较的 字典序最小的那个）

思路：

分为两步：找到最长递增子序列、如长度相等，返回按位置顺序字典值小的那一组。(复杂度较高，有待优化   ~（ =  = ) /

class Solution {
public:
    /**
     * retrun the longest increasing subsequence
     * @param arr int整型vector the array
     * @return int整型vector
     */
    vector<int> LIS(vector<int>& arr) {
        // write code here
        vector<pair<int,int>> EveryLen;
        vector<pair<int,int>> index;
        int MaxLen=1;
        for(int i{0};i<arr.size();i++){ EveryLen.push_back({arr[i],0}); }
        for(int i{1};i<arr.size();i++)
        {
            EveryLen[i].first=i;
            for(int p{0};p<i;p++)
            {
                if(arr[p]<arr[i])
                {
                   EveryLen[i].second=EveryLen[p].second+1;
                   MaxLen=max(EveryLen[i].second,MaxLen);
                }
            }
        }
        for(int i=arr.size()-1;i >=0 ;i--)
        {
            if(EveryLen[i].second==MaxLen)
            {
                index.push_back({arr[i],EveryLen[i].first});
            }
        }
        
        for(int a;a<index.size()-1;a++)
        {
            if(index[a]<index[a+1])
            {
                pair<int,int> temp =index[a];
                index[a]=index[a+1];
                index[a+1]=temp;
            }
        }
        vector<int> res;
        res.push_back(index[index.size()-1].first);
        for(int i=index[index.size()-1].second;i>1;i--)
        {
           if(arr[i]>arr[i-1])
           {
               res.push_back(arr[i-1]);
           }
        }
        reverse(res.begin(),res.end());
        return res;
    }
};

很遗憾，运行超时了。。。。

于是重构了一版：

class Solution {
public:
    struct Node
    {
        int index;
        int val;
        int len;
    };
    
    vector<int> LIS(vector<int>& arr) {
        // write code here
        vector<int> Res;
        vector<Node*> MyList,temp;
        int MaxLen{1};
        
        for(int i{};i<arr.size();i++)
        {
            Node* p = new Node{i,arr[i],1};
            MyList.push_back(p);
            for(int j{0};j<=i;j++)
            {
                if(MyList[j]->val<MyList[i]->val)
                {
                    MyList[i]->len=MyList[j]->len+1;
                    MaxLen=max(MyList[i]->len,MaxLen);
                }
            }
        }
        
        for(int i=arr.size()-1;i>=0;i--)
        {
            if(MyList[i]->len==MaxLen)
            {
                temp.push_back(MyList[i]);
            }
        }
        Node* q{};
        
        for(int i{};i<temp.size();i++)
        {
            if(temp[i]->val>temp[i+1]->val)
            {
                q=temp[i+1];
            }
            else
            {
                q=temp[i];
            }
        }
        
        Res.push_back(q->index);
        for(int i=q->index;i>0;i--)
        {
           if(arr[i]>arr[i-1])
           {
               Res.push_back(arr[i-1]);
           }
        }
        reverse(Res.begin(),Res.end());
        return Res;
    }
};

但是，空间复杂度太高了。。。。看来找准时间和空间的平衡，才是这道题解的关键啊。。。。