Leetcode——最长上升子序列

300.给定一个无序的整数数组，找到其中最长上升子序列的长度。

示例:

输入: [10,9,2,5,3,7,101,18]
输出: 4
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。
说明:

可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。
你算法的时间复杂度应该为 O(n2) 。
进阶: 你能将算法的时间复杂度降低到 O(n log n) 吗?

思路：
1.DP算法，有两个最关键的东西，一个是状态定义方程，还有一个是状态转移方程。
状态定义：DP[i] 从头到i元素，就是最长子序列的长度，我们这里就设dp为最长子序列的长度。

状态方程：i位置的dp值，由i之前的max(f(i)) (j < i)决定，并且nums[i] > nums[j]。为什么呢？因为一旦之前序列的最后一个值nums[j]大于现在即将变为整个序列最后一个元素的nums[i]，整个序列不再保持上升趋势。所以我们可以通过下列方程表示这个过程:

DP[i] = max{DP[i],DP[j]+1}

代码：

class Solution:
    def lengthOfLIS(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if nums == None or len(nums) == 0:  #如果列表是0，就返回0
            return 0
        res = 1
        dp = [1]*len(nums)
        for i in range(1,len(nums)):       	
            for j in range(i):
                if nums[j] < nums[i]:
                    dp[i] = max(dp[i],dp[j] + 1) #状态转移方程
            res = max(res,dp[i])
        return res
        

这是我们大多数人可以想到的解法，实际上这不是最快的算法，这个算法的时间复杂度是O(n^2)，我们还有比这个更快的算法。

我们建立一个临时数组tmp，将nums[0]插入其中，然后遍历nums[1:]

如果遍历到的元素val <= tmp[0]，我们更新tmp[0]=val
如果tmp[0] < val <= tmp[-1]，我们通过二分搜索法找到第一个>=val的元素位置，然后用val替换掉它
如果tmp[-1] < val，我们更新tmp.append(val)
一题目中的例子为例，我们建立一个tmp=[10]，然后我们发现10 < 9，所以我们

tmp: [9]
1
然后我们考虑9 < 2，所以

tmp: [2]
1
然后我们考虑2 < 5，所以

tmp: [2 5]
1
接着往后5 > 3 && 2 < 5，所以

tmp: [2 3]
1
而3 < 7，所以

tmp: [2 3 7]
1
接着7 < 101，所以

tmp: [2 3 7 101]
1
然后2 < 18 < 101，所以

tmp: [2 3 7 18]

class Solution:
    def lengthOfLIS(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        mem = list()
        len_nums = len(nums)
        for i in range(len_nums):
            low, upper = 0, len(mem)
            while low < upper:
                mid = (upper - low)//2 + low
                if mem[mid] < nums[i]:
                    low = mid + 1
                else:
                    upper = mid

            if upper == len(mem):
                mem.append(nums[i])
            else:
                mem[upper] = nums[i]
        
        return len(mem)