最大子序和、最长上升子序列长度

数据来源：https://leetcode-cn.com/problems/longest-increasing-subsequence/

最大子序和

 　　给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

　　代码如下所示：

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        length = len(nums)
        if length==1:
            return nums[0]
        max_ret = nums[0]
        cur_max = last_max = nums[0]
        for i in range(1, length):
            if last_max + nums[i] < nums[i]:
                cur_max = nums[i]
            else:
                cur_max = last_max + nums[i]
            if cur_max > max_ret:
                max_ret = cur_max
            last_max = cur_max
        return max_ret

最长上升子序列长度

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

　　动态规划求解：

　　　　思路：利用动态规划的思想，我们可以将问题分解为到第i个元素的最长上升子序列长度的子问题。利用mem列表记录列表第一个元素到第 i 个元素的最长上升子序列长度，cur_mem变量记录了当前元素与 mem[j<i] 对应的子序列构成的 i-1 个子序列的最长上升子序列长度。代码如下所示：

class Solution0:
    def lengthOfLIS(self, nums) -> int:
        if len(nums) == 0:
            return 0
        mem = [1 for _ in range(len(nums))]
        for i in range(1, len(nums)):
            cur_mem = []
            for j in range(i):
                if nums[i] > nums[j]:
                    cur_mem.append(mem[j] + 1)
                else:
                    cur_mem.append(1)                        
            mem[i] = max(cur_mem)
            print(mem)
        return max(mem)

　　　　算法的时间复杂度为：O(n^2)，空间复杂度O(n)。

　　　　白话：我们求第 i 个元素对应的最长上升子序列时，是求包含nums[i] 这个元素的最长子序列长度；转移状态即为：当前元素加到mem[j]，j<i 对应的子序列后，是否还是上升子序列，将是上升子序列的在对应的mem[j]上加1保存到cur_mem中，若不是，则保存1，最后将cur_mem中最大的元素保存为nums[i] ，最后输出mem中最大的元素即为最长上升子序列的长度。

　　动态规划 + 二分查找

　　　　在上面的解法中，变量列表nums是不可避免的；但是在循环里的每一步我们都需要计算 j 次(j<i)，该循环的时间复杂度为O(n)，这里的简化为使用二分法查找该长度，将时间复杂度将为O(log(n))。

　　　　思路：引入一个与nums等长的全零列表tails；定义两个指针 i， j ；循环列表nums，在每次循环进行如下操作：

　　　　   1、i，j表示要查询的范围(索引)，进行内层循环 while i<j；

　　　　   2、在内层循环中计算区间中：m = (i+j) // 2;

　　　　   3、计算tails[m]是否小于外层循环值num，若小于num，则令i = m+1；否则 j = m；

　　　　   4、内层循环结束时，将 tails[i] 赋值为 num。这里结合内层循环实现的功能是：外层循环的值若大于tails最后一个非零值则替换尾部的第一个零元素，若比它小，则替换前面序列中的一个数，这个数的前一个数比自己小(或不存在)，后一个数比自己大（或不存在），注意，tails中的非零部分是严格上升序列，虽然顺序和原序列不一定一样，但是都可以映射为原序列中的一个子序列，也即最长子序列的长度一样。

class Solution1:
    def lengthOfLIS(self, nums: [int]) -> int:
        tails, res = [0] * len(nums), 0
        for num in nums:
            i, j = 0, res
            while i < j:
                m = (i + j) // 2
                if tails[m] < num: i = m + 1 # 如果要求非严格递增，将此行 '<' 改为 '<=' 即可。
                else: j = m
            tails[i] = num
            print(tails)
            if j == res: res += 1
        return res

　　　　此算法引用：最长上升子序列（动态规划 + 二分查找，清晰图解）