目录

最长递增序列

最长上升子序列-leetcode
给定一个序列，找出其中最长的，严格递增的子序列的长度（不要求连续）。

解法一：动态规划

通过一个辅助数组记录每一个元素处的最大序列长度（在必须选这个元素的前提下），然后在坐标小于当前元素的数组扫描，在值小于当前元素的集合中选出最大值即为当前元素处的最大子序列。状态转移方程：

dp[i] = max(1, max(dp[j]+1, j<i, nums[j]<nums[i])

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        dp = []         # 用于存储每一个元素处的最大序列的长度

        n = len(nums)
        max_ = 0
        for i in range(n):
            tmp = 1
            for j in range(0,i):
                if nums[j]<nums[i]:
                    tmp = max(tmp,1+dp[j])
            dp.append(tmp)
            if max_ < tmp:
                max_ = tmp
        return max_

解法2：贪心算法

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        if not nums:
            return 0
        dp = [nums[0]]
        n = len(nums)
        for i in range(1,n):
            if nums[i] > dp[-1]:
                dp.append(nums[i])
                continue
            for j in range(len(dp)):
                if nums[i]<dp[j]:
                    dp[j] = nums[i]
                    break
                if nums[i] == dp[j]: # 避免相等的数重复入组

        return len(set(dp))

最长公共子序列

最长公共子序列-牛客网

两个数组中，最长的相等的子序列（不要求连续）。

解法1：动态规划

以两个字符串为例：

str1 = 1a2b3c

str2 = 123abc

可以归纳出：

  1. 当str1[i] = str2[j]时，此时的最大子序列长度应该等于左上角的值加上1（当i=0时为1，因为此时没有左上角）；

  2. 当str1[i] != str2[j]时，此时的最大子序列长度为上方和左方的最大值（当i=0时直接为上方的值）

如下图所示

class LCS:
    def findLCS(self, A, n, B, m):
        dp1 = [0 for i in range(n)] # 
        for i in range(m):
            dp2 = [0 for each in range(n)]
            for j in range(n):
                if B[i] == A[j]:
                    dp2[j] = dp1[j-1]+1 if j>0 else 1
                else:
                    dp2[j] = max(dp2[j-1],dp1[j]) if j>0 else dp1[j]
            dp1 = dp2
        return dp2[-1]

最长公共子串

最长公共子串-牛客网
最长公共子串：两个字符串中连续相等的最长子串。

解法一：动态规划

具体dp过程如图所示：

class LongestSubstring:
    def findLongest(self, A, n, B, m):
        dp = [[0 for i in range(n)] for j in range(m)]
        max_ = 0
        for i in range(m):
            for j in range(n):
                if B[i] == A[j]:
                    if i>0 and j >0:
                        dp[i][j]=dp[i-1][j-1] +1
                    else:
                        dp[i][j] = 1
                    if dp[i][j]>max_:
                        max_=dp[i][j]
        return max_