寻找最长子序列 DP和稀疏DP

leetcode Q1143

基本DP的算法思路如下，其复杂度为O(mn)

import collections
class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        # 基本DP解法：AC
        m,n = len(text1),len(text2)
        dp = [[0 for i in range(n)] for j in range(m)]
        for i in range(m):
            for j in range(n):
                if text1[i] == text2[j]:
                    if i-1>-1 and j-1>-1:
                        dp[i][j] = dp[i-1][j-1]+1
                    else:
                        dp[i][j] = 1
                else:
                    t1,t2 = 0,0
                    if i-1>-1:
                        t1 = dp[i-1][j]
                    if j-1>-1:
                        t2 = dp[i][j-1]
                    dp[i][j] = max(t1,t2)
        return dp[-1][-1]

另一种方法，利用DP时匹配点对在匹配矩阵中的稀疏性，在上一个基本的DP的思路中，我们意识到，只有匹配点对的对应的矩阵元素我们需要进行计算之外，其他的矩阵元素我们不需要进行计算，这样可以节省大量的冗余计算，针对数据进行有选择性的算法优化，算法复杂度为O(mlogm+nlogn+K^2),算法如下：

稀疏DP解法，当匹配点对在矩阵中稀疏的情况下好使
class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        m,n = len(text1),len(text2)
        matches = self.findMatch(text1,text2)
        matches.sort()
        matches.append((m+1,n+1))
        K = len(matches)
        opt = [0 for i in range(K)]
        for i in range(K):
            ix,iy = matches[i]
            opt[i] = 1
            for j in range(i):
                ix1,iy1 = matches[j]
                if ix1<ix and iy1<iy:
                    opt[i] = max(opt[i],1+opt[j])
        return opt[-1]-1
    def findMatch(self,s1,s2):
        dic = collections.defaultdict(lambda : [[],[]])
        for i in range(len(s1)):
            dic[s1[i]][0].append(i)
        for j in range(len(s2)):
            dic[s2[j]][1].append((j))
        matches = []
        for val in dic.values():
            matches.extend([(i,j) for i in val[0] for j in val[1]])
        return matches