Python 动态规划算法求解最长公共子序列

前言：在网上看到一道360的秋招真题，题目如下：

仔细读题后发现这是一道求解最长公共子序列的问题，最好使用动态规划算法。

题目大意：

小B坐火车，从起点到终点的车站序列已知，期间他睡了两觉，到终点的时候还在睡，也就是说中间他醒了两次，这两次清醒的时间，有两个车站子序列，现在让我们分析这两段路是去的时候看到的，还是回来的时候看到的，来回都能看到，还是说压根不存在。

思路：

一共有四种结果：

forward

backward

invalid

both

首先将两个子串连接，判断连接后的子串是否正好是与总串的最长公共子序列

若是，则forward验证

然后反转总串，再判断连接后的子串是否正好是与总串的最长公共子序列

若是，则backward验证

若都不是则不存在这样的车站序列

算法简介：

1、最长公共子序列的结构（问题的最优子结构性质）

2、子问题的递归结构（建立递归关系）

 由最优子结构性质可知，要找出X和Y的最长公共子序列可按以下方式递归地进行：

（1）当xm=yn时，找出Xm-1和Yn-1的最长公共子序列。

（2）当xm≠yn时，必须解两个子问题，找出Xm-1和Y的一个最长公共子序列及X和Yn-1的一个最长公共子序列。这两个公共子序列中较长者即为X和Y的一个最长公共子序列。

数据结构1：用C[i][j]记录序列和的最长公共子序列的长度

数据结构2：用B[i][j]记录当前序列和的来源

(1)若C[i][j]由C[i-1][j-1]得到，B[i][j] = 1

(2)若C[i][j]由C[i-1][j]得到，B[i][j] = 2

(3)若C[i][j]由C[i][j-1]得到，B[i][j] = 3

Python2.7实现：

我的代码：

# encoding :utf-8def lcs(k, l, slist, B):    if k == 0 or l == 0:        return    if B[k][l] == 1:        res.append(slist[k])        lcs(k - 1, l - 1, slist, B)    elif B[k][l] == 2:        lcs(k, l - 1, slist, B)    else:        lcs(k - 1, l, slist, B)def lcs2(k, l, sslist, B):    if k == 0 or l == 0:        return    if B[k][l] == 1:        res.append(sslist[k])        lcs2(k - 1, l - 1, sslist, B)    elif B[k][l] == 2:        lcs2(k, l - 1, sslist, B)    else:        lcs2(k - 1, l, sslist, B)while 1:    fo = 0    ba = 0    s = raw_input()    a = raw_input()    b = raw_input()    ss = s[::-1]    slist = list(s)    slist.insert(0, '0')    ablist = list(a + b)    ablist.insert(0, '0')    sslist = list(ss)    sslist.insert(0, '0')    C = [([0] * len(ablist)) for i in range(len(slist))]    B = [([0] * len(ablist)) for i in range(len(slist))]    CC = [([0] * len(ablist)) for i in range(len(sslist))]    BB = [([0] * len(ablist)) for i in range(len(sslist))]    # print C    # print slist    # print ablist    res = []    for i in range(1, len(slist)):        for j in range(1, len(ablist)):            if slist[i] == ablist[j]:                C[i][j] = C[i - 1][j - 1] + 1                B[i][j] = 1            elif C[i - 1][j] > C[i][j - 1]:                C[i][j] = C[i - 1][j]                B[i][j] = 3            else:                C[i][j] = C[i][j - 1]                B[i][j] = 2    lcs(len(slist) - 1, len(ablist) - 1, slist, B)    print ablist    print res    if res[::-1] == ablist[1:]:        fo = 1    res = []    for i in range(1, len(sslist)):        for j in range(1, len(ablist)):            if sslist[i] == ablist[j]:                CC[i][j] = CC[i - 1][j - 1] + 1                BB[i][j] = 1            elif CC[i - 1][j] > CC[i][j - 1]:                CC[i][j] = CC[i - 1][j]                BB[i][j] = 3            else:                CC[i][j] = CC[i][j - 1]                BB[i][j] = 2    lcs2(len(sslist) - 1, len(ablist) - 1, sslist, BB)    print res    if res[::-1] == ablist[1:]:        ba = 1    if fo == 1 and ba == 0:        print "forward"    elif fo == 0 and ba == 1:        print "backward"    elif fo == 1 and ba == 1:        print "both"    else:        print "invalid"

别人的代码：

while 1:    a = raw_input()    b = raw_input()    c = raw_input()    e = len(b)    if (b in a) & (c in a):        bl = a.find(b)        if bl + e <= len(a) - 1:            if a.find(c, bl + e) > 0:                res = 1            else:                res = 0        else:            res = 0    else:        res = 0    d = a[::-1]    if (b in d) & (c in d):        bl = d.find(b)        if bl + e <= len(a) - 1:            if d.find(c, bl + e) > 0:                res += 2            else:                res += 0        else:            res += 0    else:        res += 0    if res == 0: print'invalid'    if res == 1: print'forward'    if res == 2: print'backward'    if res == 3: print'both'

看了人家的代码才体会到什么是差距，人家的代码简洁而又漂亮。这里再恶补一下find函数是怎么用的，发现没有，有了find函数，根本就不需要写求解最长公共子序列的函数了…

简介：find是字符串类型的成员函数

函数原型：s.find(str, pos_start, pos_end)

解释：

• str: 在s中被查找的“子串”
• pos_start: 查找的首字母位置（从0开始计数。默认：0）
• pos_end: 查找的末尾位置（默认-1）

返回值：如果查到：返回查找的第一个出现的位置。否则，返回-1。