经典算法题每日演练——最长公共子序列

一： 作用

最长公共子序列的问题常用于解决字符串的相似度，是一个非常实用的算法，作为码农，此算法是我们的必备基本功。

二：概念

举个例子，cnblogs这个字符串中子序列有多少个呢？很显然有27个，比如其中的cb,cgs等等都是其子序列，我们可以看出子序列不见得一定是连续的，连续的那是子串。

 我想大家已经了解了子序列的概念，那现在可以延伸到两个字符串了，那么大家能够看出：cnblogs和belong的公共子序列吗？

在你找出的公共子序列中，你能找出最长的公共子序列吗？

从图中我们看到了最长公共子序列为blog，仔细想想我们可以发现其实最长公共子序列的个数不是唯一的，可能会有两个以上，

但是长度一定是唯一的，比如这里的最长公共子序列的长度为4。

三：解决方案

• 枚举法
  这种方法是最简单，也是最容易想到的，当然时间复杂度也是龟速的，我们可以分析一下，刚才也说过了cnblogs的子序列，个数有27个 ，延伸一下：一个长度为N的字符串，其子序列有2**N个，每个子序列要在第二个长度为N的字符串中去匹配，匹配一次

需要O(N)的时间，总共也就是O(N*2**N)，可以看出，时间复杂度为指数级，恐怖的令人窒息。

• 动态规划
  既然是经典的题目肯定是有优化空间的，并且解题方式是有固定流程的，这里我们采用的是矩阵实现，也就是二维数组。
  第一步：先计算最长公共子序列的长度。
  第二步：根据长度，然后通过回溯求出最长公共子序列。
  现有两个序列X={x1,x2,x3，…xi}，Y={y1,y2,y3，…，yi}，
  将 X 和 Y 的最长公共子序列记为LCS(X,Y)，如果 xn=ym，即X的最后一个元素与Y的最后一个元素相同，这说明该元素一定位于公共子序列中。因此，现在只需要找：LCS(Xn-1，Ym-1)就好，LCS(X,Y)=LCS(Xn-1，Ym-1)+1；如果xn != ym，这下要麻烦一点，因为它产生了两个子问题：LCS(Xn-1，Ym) 和 LCS(Xn，Ym-1)。

设一个C[i,j]: 保存Xi与Yj的LCS的长度。

递推方程为：

# 采用矩阵实现
def maxTwoArraySameOrderMethod(strA,strB):
    resultlist=[]
    a=len(strA)
    b=len(strB)
    # for i in range(0,a+1):
    #     resultlist.append([])
    #     for j in range(0,b+1):
    #         resultlist[i].append(0)
    resultlist=[[0]*(b+1) for i in range(a+1)]
    for i in range(1,a+1):
        for j in range(1,b+1):
            if strA[i-1] == strB[j-1]:
                resultlist[i][j]=resultlist[i-1][j-1]+1
            else:
                resultlist[i][j]=max(resultlist[i][j-1],resultlist[i-1][j])

    return resultlist[a][b]

#递归实现
def diguimaxTwoArraySameOrderMethod(strA,strB):
    def dp(a,b):
        if a == -1 or b == -1:
            return 0
        if strA[a] == strB[b]:
            return dp(a-1,b-1)+1
        else:
            return max(dp(a-1,b),dp(a,b-1))
    return dp(len(strA)-1,len(strB)-1)

print(maxTwoArraySameOrderMethod('cnblogs','belong'))

我们来分析下它的时间复杂度和空间复杂度。

• 时间复杂度：构建矩阵我们花费了O(MN)的时间，回溯时我们花费了O（M+N)的时间，两者相加最终我们花费了O(MN)的时间。

• 空间复杂度：构建矩阵我们花费了O(MN)的空间，标记函数也花费了O(MN)的空间，两者相加最终我们花费了O(MN)的空间。