【DP】300. Longest Increasing Subsequence

时间复杂度为o(n**2)时：

class Solution:
    def lengthOfLIS(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums)==0:
            return 0
        
        table=[]       
        for i in range(len(nums)):
            table.append(1);
            
        for i in range(len(nums)):
            for j in range(i):
                if nums[j]<nums[i]:
                    table[i]=max(table[i],1+table[j])
        return max(table)

时间复杂度为o(nlogn)时：

class Solution:
    def lengthOfLIS(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        
        if len(nums)==0:
            return 0
        table = []
        for i in range(len(nums)):
            low = 0
            high = len(table)-1
            while low<=high:
                mid = (low+high)//2
                if table[mid]<nums[i]:
                    low = mid + 1
                else:
                    high = mid - 1
                
            if low >= len(table):
                table.append(nums[i])
            else:
                table[low]=nums[i]
        
        return len(table)
                        
                    
                        

class Solution {
public:
    int lengthOfLIS(vector<int>& table) 
    {
        if(table.size()<1)
            return 0;
        vector<int> ans(table.size(), 1);  //记录以table[i]为结尾元素的递增序列的最长长度
        vector<int> temp(1, table[0]);  //temp[i]表示截至当前遍历，所有(i+1)长度的递增序列的最小结尾元素
        int sum = 1;

        for (int i = 1; i < table.size(); i++)
        {
            int l = 0, r = temp.size() - 1;
            if(table[i]>temp[r])
                l=temp.size();  //table[i]比temp中所有元素都大
            else
            {
                while (l <= r)
                {
                    int mid = l + (r - l) / 2;
                    if (temp[mid] < table[i])
                        l = mid + 1;
                    else
                        r = mid - 1;
                }
            }  //在temp中找到table[i]的插入位置，即可获悉以table[i]为结尾的最长递增序列长度

            if (l >= temp.size())
            {
                temp.push_back(table[i]);
                ans[i] = temp.size();
            }  //table[i]比temp中所有元素都大，则表示获取到了一个新的最长递增序列长度
            else
            {
                temp[l] = table[i];
                ans[i] = l + 1;
            }
            sum = max(sum,ans[i]);  //更新最长递增序列长度
        }
        return sum;
    }
};