LintCode-最长上升子序列（LIS）

最长上升子序列
给定一个整数序列，找到最长上升子序列（LIS），返回LIS的长度。

样例
给出 [5,4,1,2,3]，LIS 是 [1,2,3]，返回 3
给出 [4,2,4,5,3,7]，LIS 是 [2,4,5,7]，返回 4

挑战
要求时间复杂度为O(n^2) 或者 O(nlogn)

说明
最长上升子序列的定义：

最长上升子序列问题是在一个无序的给定序列中找到一个尽可能长的由低到高排列的子序列，这种子序列不一定是连续的或者唯一的。

O(n^2)算法思路
举个栗子：求 2 7 1 5 6 4 3 8 9 的最长上升子序列。我们定义d(i) (i∈[1,n])来表示前i个数以A[i]结尾的最长上升子序列长度。

前1个数 d(1)=1 子序列为2；

前2个数 7前面有2小于7 d(2)=d(1)+1=2 子序列为2 7

前3个数 在1前面没有比1更小的，1自身组成长度为1的子序列 d(3)=1 子序列为1

前4个数 5前面有2小于5 d(4)=d(1)+1=2 子序列为2 5

前5个数 6前面有2 5小于6 d(5)=d(4)+1=3 子序列为2 5 6

前6个数 4前面有2小于4 d(6)=d(1)+1=2 子序列为2 4

前7个数 3前面有2小于3 d(3)=d(1)+1=2 子序列为2 3

前8个数 8前面有2 5 6小于8 d(8)=d(5)+1=4 子序列为2 5 6 8

前9个数 9前面有2 5 6 8小于9 d(9)=d(8)+1=5 子序列为2 5 6 8 9

d(i)=max{d(1),d(2),……,d(i)} 我们可以看出这9个数的LIS为d(9)=5

总而言之，d(i)就是找以A[i]结尾的，在A[i]之前的最长上升子序列+1，当A[i]之前没有比A[i]更小的数时，d(i)=1。所有的d(i)里面最大的那个就是最长上升子序列。

O(n^2)代码：（返回最长上升子序列的长度）

class Solution:
    """
    @param nums: An integer array
    @return: The length of LIS (longest increasing subsequence)
    """

    def longestIncreasingSubsequence(self, nums):
        if nums == []:
            return 0
        result = []
        for key, val in enumerate(nums):
            result.append(1)
            max_length_some = []
            for index in range(0, key):
                if val > nums[index]:
                    max_length_some.append(result[index])
            max_length = 0
            for length in max_length_some:
                if length > max_length:
                    max_length = length
            result[key] = result[key] + max_length
        return max(result)

O(n^2)代码：（返回最长上升子序列）

class Solution:
    """
    @param nums: An integer array
    @return: The length of LIS (longest increasing subsequence)
    """

    def longestIncreasingSubsequence(self, nums):
        if nums == []:
            return 0
        result = []
        for key, val in enumerate(nums):
            result.append([val])
            max_list_some = []
            for index in range(0, key):
                if val > nums[index]:
                    max_list_some.append(result[index])
            max_length = 0
            max_key = 0
            for key0, val0 in enumerate(max_list_some):
                if len(val0) > max_length:
                    max_length = len(val0)
                    max_key = key0
            try:
                result[key].extend(max_list_some[max_key])
            except IndexError:
                pass
        result_max_length = 0
        result_max_key = 0
        for key1, val1 in enumerate(result):
            if len(val1) > result_max_length:
                result_max_length = len(val1)
                result_max_key = key1
        return result[result_max_key]

超级笨的搜索树办法，0（n！），以此为告诫：

class Solution:
    """
    @param nums: An integer array
    @return: The length of LIS (longest increasing subsequence)
    """

    def longestIncreasingSubsequence(self, nums):
        max_num = [0]
        max_list = []
        result = []
        for key, val in enumerate(nums):
            if max_list == []:
                max_list.append(val)
                self.Maxlist(nums[key+1:], max_num, max_list, result)
                max_list.pop()
        return result

    def Maxlist(self, nums, max_num, max_list, result):
        for key, val in enumerate(nums):
            new_nums = nums[key+1:]
            flag = 0
            if val > max_list[-1]:
                max_list.append(val)
                flag = 1
                if len(new_nums) + len(max_list) > max_num[0]:
                    self.Maxlist(new_nums, max_num, max_list, result)

            if (len(max_list) > max_num[0]):
                max_num[0] = len(max_list)
                result.clear()
                for i in max_list:
                    result.append(i)
            if flag == 1:
                max_list.pop()

AC是不可能了，这辈子都不可能了，真能卡在TimeLimitExceeded上混吃等死。