天天刷leetcode——300. 最长上升子序列,1143. 最长公共子序列,674. 最长连续递增序列,152.乘积最大子数组

300. 最长上升子序列

题目描述

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

解题思路

1. 动态规划

状态：$dp[i]$以nums[i]结尾的序列的最长递增子序列的长度。

比如：$nums[10,12,3,5,7,8]$, $dp[0]$表示以$nums[0]$结尾的最长递增子序列的长度为1。对于$dp[5]$表示以$nums[5]=8$结尾的最长递增子序列为3。

状态转移方程：递增序列，只需要找到$nums[i]$前面比$nums[i]$小的子序列，然后把$nums[i]$接到最后，就可以形成一个新的递增子序列。即，新的子序列就是找到的数后加个$nums[i]$，长度加一。会找到不同的子序列，只需要找到长度最长的那个就可以了。比较当$dp[i]$ 的长度和$dp[i]$对应产生新的子序列长度，我们用$j$来表示所有比$i$小的组数中的索引,过程如下：

for i in range(len(nums)):
	for j in range(i):
		if nums[i] > nums[j]:
			dp[i] = max(dp[i],dp[j]+1)

初始条件：$dp[0]$ = 1

    def lengthOfLIS(self, nums: List[int]) -> int:
        # dp[i] 表示长度为i的序列的最长上升子序列的长度
        if len(nums)<1:
            return 0
        dp = [1 for i in range(len(nums))]
        for i in range(len(nums)):
            for j in range(i):
                if nums[i] > nums[j]:
                    dp[i] = max(dp[i],dp[j]+1)
        return max(dp)

时间复杂度$O(n^2)$

2. 优化

遍历列表$dp$需要$O(N)$,计算每个$dp[i]$需要$O(N)$,总体时间复杂度为$O(N^2)$ 。 遍历dp的时间复杂度无法降低，后续需要每轮遍历$[0,i]$的$dp[i]$元素的时间复杂度可以优化。让dp变成一个排序列表。

674. 最长连续递增序列

状态：$dp[i]$ 表示以$nums[i]$结尾的最长连续递增序列长度
状态转移：如果$nums[i]>nums[i-1]$, $dp[i]=dp[i-1]+1$。否则dp[i] = 1。

    def findLengthOfLCIS(self, nums: List[int]) -> int:
        if len(nums)<1:
            return 0
        dp = [1 for i in range(len(nums))]
        for i in range(1,len(nums)):
            if nums[i] > nums[i-1]:
                dp[i] = dp[i-1]+1
            else:
                dp[i] = 1
        return max(dp)

5. 最长回文子串

状态： $dp[j][i]$表示序列$s[j:i+1]$是否为回文子串
状态转移：$(s[i]==s[j]andi-j<2)or(s[i]==s[j]anddp[j+1][i-1]==1)$则$dp[j][i]=1$

    def longestPalindrome(self, s: str) -> str:
        # dp[i][j] 表示是否是回文子串
        if len(s) < 1:
            return ''
        result = []
        dp = [[0] * len(s) for _ in range(len(s))]
        for i in range(len(s)):
            for j in range(i+1):
                if (s[i] == s[j] and i -j < 2) or (s[i] == s[j] and dp[j+1][i-1]==1):
                    dp[j][i] = 1
                    result = s[j:i+1] if len(s[j:i+1]) > len(result) else result
        return result

1143. 最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。
状态：$dp[i][j]$表示$text1[1:i]$和$text2[1:j]$的最长公共子序列.
状态转移矩阵：

状态转移：

1. 如果$text1[i-1]==text2[j-1]$，$dp[i][j]=1+dp[i-1][j-1]$
2. 如果不等，$dp[i][j]=max(dp[i-1][j],dp[i][j-1])$

    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        m, n = len(text1), len(text2)
        dp = [[0] * (n + 1) for _ in range(m + 1)]
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if text1[i - 1] == text2[j - 1]:
                    # 找到一个 lcs 中的字符
                    dp[i][j] = 1 + dp[i-1][j-1]
                else:
                    dp[i][j] = max(dp[i-1][j], dp[i][j-1])
        return dp[-1][-1]

516. 最长回文子序列

给定一个字符串 s ，找到其中最长的回文子序列，并返回该序列的长度。可以假设 s 的最大长度为 1000 。
状态：$dp[i][j]$表示序列字符串第i个字符到第j个字符的最大子序列长度，子问题也就是每个回文子串的长度
转移矩阵：

转移：

1. $s[i]==s[j]，s[i+1...j-1]$这个字符串$+2$就是最长回文子序列
2. 当$s[i]/=s[j]$,则说明只有一个出现在s[i,j]的最长回文子序列中。我们只需要取$s[i-1,j-1]$加上$s[i]$或者$s[j]$的数值中较大的。

if s[i] == s[j]:
	dp[i][j] = dp[i+1][j-1]+2
else:
	dp[i][j] = max(dp[i][j-1],dp[i+1][j])

初始化：$dp[i][j]=1(i=j)$,$dp[i][j]=0(i>j)$
最后直接返回$dp[0][-1]$

        dp = [[0]*len(s) for _ in range(len(s))] 
        # print(dp)
        for i in range(len(s)):
            dp[i][i] = 1
         # 从右下角开始
        for i in range(len(s),-1,-1):
            for j in range(i+1,len(s)):
                if s[i]==s[j]:
                    dp[i][j] = dp[i+1][j-1]+2
                else:
                    dp[i][j] = max(dp[i][j-1],dp[i+1][j])
        return dp[0][-1]

72. 编辑距离

152. 乘积最大子数组

给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。

解题思路：

1. 暴力求解

其实就是求解这样的一个矩阵，中最大的值。两次for循环就可以了。

def maxProduct(nums):
    if len(nums) < 2:
        return nums[0]
    maxR = -float('inf')
    dp = [[-float('inf')] * len(nums) for _ in range(len(nums))]
    for i in range(len(nums)):
        dp[i][i] = nums[i]
    for i in range(len(nums)):
        for j in range(i + 1, len(nums)):
            dp[i][j] = (dp[i][j - 1]) * nums[j]
    for i in range(len(nums)):
        for j in range(i, len(nums)):
            if maxR < dp[i][j]:
                maxR = dp[i][j]
    return maxR

时间复杂度太高了，最后一个过不了。哭哭！

2. 动态规划来啦

创建一个$dp[i]$，记录当前位置的满足条件的最大值与最小值；

该问题只需要考虑在当前位置所能够取到的最大值与最小值；例如：若是取到$i$位置时，只需要找到$i$的上一个即$i-1$能够取得的最大值与最小值。
因为不确定$nums[i]$值的正负，故我们需要记录$i-1$位置的最大最小值，以便求得$i$位置的最大最小值。

• $nums[i]>=0$:
  $dp\_max[i]=max(dp\_max[i-1]\ast nums[i],nums[i])$
  $dp\_min[i]=min(dp\_min[i-1]\ast nums[i],nums[i])$

• $nums[i]<0$:
  $dp\_max[i]=max(dp\_min[i-1]\ast nums[i],nums[i])$
  $dp\_min[i]=min(dp\_max[i-1]\ast nums[i],nums[i])$

    def maxProduct(self, nums: List[int]) -> int:
        if not nums:
            return 0
        elif len(nums)<2:
            return nums[0] 
        nums_len = len(nums)
        result = nums[0]
        # dp dp_max和dp_min分别表示前i个元素的最大值和最小值
        dp_max,dp_min = [0] * nums_len,[0]*nums_len
        dp_max[0],dp_min[0] = nums[0],nums[0]
        for i in range(1,nums_len):
            # 如果nums[index]大于0
            if nums[i] >= 0:
                dp_max[i] = max(nums[i],dp_max[i-1]*nums[i])
                dp_min[i] = min(nums[i],dp_min[i-1]*nums[i])
            else:
                dp_max[i] = max(nums[i],dp_min[i-1]*nums[i])
                dp_min[i] = min(nums[i],dp_max[i-1]*nums[i])
            result = max(result,dp_max[i])
        return result

reference

[1]Leetcode 152.乘积最大子数组https://leetcode-cn.com/problems/maximum-product-subarray/submissions/
[2] Leetcode 674. 最长连续递增序列
[3] Leetcode 1143. 最长公共子序列
[4] Leetcode 300. 最长上升子序列