代码随想录算法训练营第五十二天｜300.最长递增子序列 674. 最长连续递增序列 718. 最长重复子数组

300.最长递增子序列

https://leetcode.com/problems/longest-increasing-subsequence/

思路： 动态规划的想法是用一个一维数组记录数组到每个下标时候的最大递增序列的长度，然后外层循环数组， 再数组下标为 i 时， 循环dp数组从 0-i-1. 如果nums[i] > nums[j], 那么dp[i] = max(dp[j] + 1, dp[i]) 否则，dp[i] = max(dp[j], dp[i]).

更快速的方法使用二分搜索， 用一个list 记录前面出现过的到每个长度的“最优解”。 例如nums = [1, 2, 100, 0, 1, 2, 3]. 初始化list = [1], 然后从下标1 开始遍历数组，如果nums[i]  > list[-1] 说明是递增的， 就把nums[i] append 到 list 里面。 例子中循环到下标2 之后list 变成[1, 2, 100]. 如果nums[i] <= list[-1], 说明到这个元素，最长值不增加了， 但是“最优解”也变了。 例子中循环到下标3，之后的元素如果高于0 就可以组成一个长度为2 的递增子序列（最优解中，1 变成了0）， list 变成[0, 2, 100], 下标4 list = [0, 1, 100], 下标5 list = [0, 1, 2], 然后下标6 的 3 就判断为最长递增序列的第四个元素。不难发现list 数组是单调递增的， 所以可以用二分法确定要替换的元素的下标。

难点： 二分法比较难想到的

class Solution:
    def __BS(self, nums: List[int], target: int) -> int:
        # Input: sorted list and a target value 
        # Output if target value in nums return -1.
        # if the target value not in nums, return index of the element just great than target.
        if target > nums[-1]:
            return len(nums)
        left, right = 0, len(nums)-1
        while left < right:
            mid = (left + right) // 2
            if nums[mid] == target:
                return mid
            elif nums[mid] > target:
                right = mid
            else:
                left = mid + 1
        return right

    def lengthOfLIS(self, nums: List[int]) -> int:
        _tmp_list = [nums[0]]
        for i in range(1, len(nums)):
            if nums[i] > _tmp_list[-1]:
                _tmp_list.append(nums[i])
            else:
                index = self.__BS(_tmp_list, nums[i])        
                _tmp_list.insert(index, nums[i])
                _tmp_list.pop(index+1)
        return len(_tmp_list)

674. 最长连续递增序列

https://leetcode.com/problems/longest-continuous-increasing-subsequence/

思路： 要求连续的， 那这个就简单多了。 遇到nums[i] <= nums[i-1] 就把current reset成1. ans = max(ans, current).

难点： 无

class Solution:
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        ans, current = 1, 1
        for i in range(1, len(nums)):
            if nums[i] > nums[i-1]:
                current += 1
                ans = max(ans, current)
            else:
                current = 1
        return ans

718. 最长重复子数组  

https://leetcode.com/problems/maximum-length-of-repeated-subarray/description/

思路： 这个问题要注意审题， 首先它要求是顺序的， 然后要求是连续的。 那我们的思路就是稍微搞懂一下 longest common subsequance 就可以了，碰到nums[i] != nums[j] 就reset成0. nums[i] == nums[j] 就让dp[i+1][j+1] = dp[i][j] + 1. 最后的输出要注意输出dp 数组中的最大值。 

难点： 这个里面dp 数组的值的定义稍有不同， 表示的是 nums1， nums2 分别从下标 i， j 往前数有几个共同元素。 

class Solution:
    def findLength(self, nums1: List[int], nums2: List[int]) -> int:
        dp = [[0] * (len(nums1) + 1) for _ in range(len(nums2)+1)]
        for i, num2 in enumerate(nums2):
            for j, num1 in enumerate(nums1):
                if num2 == num1:
                    dp[i+1][j+1] = dp[i][j] + 1
                else:
                    dp[i+1][j+1] = 0
        return max([max(row) for row in dp])