動態規劃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_