动态规划1——最长递增子序列、最长公共子序列、最长公共子串（python实现）

目录

• • 2. 最长公共子序列
  • 3. 最长公共子串

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

解法一：动态规划

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

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:
        n = len(nums)
        if n == 0:
            return 0
        dp = [nums[0]]

        for i in range(1,n):
            if nums[i] > dp[-1]:
                dp.append(nums[i])
                continue

            l,r = 0, len(dp)-1
            while l < r:
                mid = (l+r-1)//2 
                if dp[mid] < nums[i]:
                    l = mid + 1
                else:
                    r = mid        
            dp[l] = nums[i]      

        return len(dp)

---

2. 最长公共子序列

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

解法1：动态规划

以两个字符串为例：

str1 = 1a2b3c

str2 = 123abc

	1	a	2	b	3	c
1	1	1	1	1	1	1
2	1	1	2	2	2	2
3	1	1	2	2	3	3
a	1	2	2	2	3	3
b	1	2	2	3	3	3
c	1	2	2	3	3	4

从上表能够看出：

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]

---

3. 最长公共子串

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

解法一：动态规划

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_