精华内容
下载资源
问答
  • 最长公共子序列python

    千次阅读 2019-04-14 15:52:08
    最长公共子序列是来自于leetcode的一道编程题。典型的动态规划思路,动态规划相比于递归算法的重要区别在于:递归算法是从完整的大规模问题逐步划分为小规模的问题,是自顶向下的分而治之策略。而动态规划则是从小...

    最长公共子序列是来自于leetcode的一道编程题。典型的动态规划思路,动态规划相比于递归算法的重要区别在于:递归算法是从完整的大规模问题逐步划分为小规模的问题,是自顶向下的分而治之策略。而动态规划则是从小规模问题着手,自底向上的思路。动态规划也可以理解为是迭代的思路,当前状态的数值取决于前面时刻的状态,这种情况下将使用动态规划会比代码看上去很简单的递归算法节省很多重复的递归实例计算。

    子序列指的是:在字符串中取出某些字符构成新字符串,在原字符串和新字符串中的字符相对位置不变。

    动态规划的具体思路如下:
    首先考虑两个长的完整字符串advantage和didactical,记作A和B,它们的公共子序列怎么求解呢?考虑两个长字符串的最后一个字符A[-1]和B[-1],试想:如果最后一个字符相等A[-1]=B[-1],则最长子序列长度为字符串A[:-1]和B[:-1]的最长子序列长度+1,这里对于列表的索引采用python的习惯,也就是:左闭右开区间,右边界的端点值取不到。如果A[-1]!=B[-1],也就是例子中的情况,则最长子序列的长度等于 max(A[:-1]和B的最长子序列,A和B[:-1]的最长子序列)。

    解决方案是填充一个二维表格,先填充第1行所有列,再填充第二行所有列的顺序,这样每当要求表格中当前数值时,只需判断当前位置上的两个字符是否相等,如果相等,则等于对角线上上一个位置的值加1,否则等于其上方和其左方的最大值,对于表格的填充顺序必须满足这样的方案可行。

    # -*- coding:utf-8 -*-
    
    class LCS:
        def findLCS(self, A, n, B, m):
            # write code here
            table=[[0 for i in range(m+1)] for j in range(n+1)]
            print(len(table),len(table[0]))
            for p in range(1,n+1):
                for q in range(1,m+1):
                    if A[p-1]==B[q-1]:
                        table[p][q]=table[p-1][q-1]+1
                    else:
                        print(p,q)
                        print(table[p-1])
                        print(table[p])
                        table[p][q]=max(table[p-1][q],table[p][q-1])
            return table[n][m]
    if __name__=='__main__':
        output=LCS().findLCS("1A2C3D4B56",10,"B1D23CA45B6A",12)
        print(output)

     

    展开全文
  • 最长公共子序列 python

    千次阅读 2017-09-26 08:38:22
    注意:子序列和子串的区别,前者是字符串里的不相隔的字符组成的串,字符的先后顺序不变;后者是连续的字符组成的字符串 实现下面的递推式,就实现了dp动归。更多图解的过程,可以参看博客...

    注意:子序列和子串的区别,前者是字符串里的不相隔的字符组成的串,字符的先后顺序不变;后者是连续的字符组成的字符串

    实现下面的递推式,就实现了dp动归。更多图解的过程,可以参看博客http://blog.csdn.net/hrn1216/article/details/51534607




    class LCS:
        def findLCS(self, A, n, B, m):
            if m == 0 or n == 0:
                return -1
            c = [[0 for _ in xrange(m + 1)] for _ in range(n + 1)]
            for i in range(1, n + 1):
                for j in range(1, m + 1):
                    if A[i - 1] == B[j - 1]:
                        c[i][j] = c[i - 1][j - 1] + 1
                    else:
                        c[i][j] = max(c[i][j - 1], c[i - 1][j])
            return c[-1][-1]
    
    if __name__ == '__main__':
        line = raw_input().split(',')
        A = line[0][1:-1]
        n = int(line[1])
        B = line[2][1:-1]
        m = int(line[-1])
        print LCS().findLCS(A, n, B, m)


    以上的代码中,如果将 c的定义改成 c=[[0 for _ in range(m + 1)]]*(n+1)  结果始终不对,为什么?这里需要明白二者的区别,这是个大坑,如下图


    后面一种方式定义的是一种引用,修改其中一个,其他的也会发生变化


    参考文献

    http://blog.csdn.net/hrn1216/article/details/51534607

    http://www.cnblogs.com/zfyouxi/p/4195215.html


    展开全文
  • 最长公共子序列python实现

    千次阅读 2019-08-14 23:43:01
    最长公共子序列python实现 1、dp基本思路: 公共子序列最优子结构: 将问题分解表成更简单的子问题,这个子问题可以分解成更多的子问题使用动态规划算法求解,这个过程需要在一个表中储存同一级别的子问题的解,...

    最长公共子序列python实现

    1、dp基本思路:

    公共子序列最优子结构:
    将问题分解表成更简单的子问题,这个子问题可以分解成更多的子问题使用动态规划算法求解,这个过程需要在一个表中储存同一级别的子问题的解,因此这个解可以被更高级的子问题使用。

    2、问题的解

    定义两个序列X、Y,二维数组f[i][j]表示X的i位和Y的j位之前的最长公共子序列长度,
    则有
     f[1][1] = same(1,1)
     f[i][j] = max(f[i-1][j-1]+same(i,j),f[i-1][j],f[i][j-1)

    其中same(i,j)表示X[i]==Y[j]
     same(a,b)当X的第a位于Y的第b位完全相同时为1,否则为0
     此时,f[i][j]中最大的数便是 X和 Y的最长公共子序列的长度,依据该数组回溯,便可找出最长公共子序列。

    如:

    X = 'helloword'
    Y = 'eoskod'

    X,Y的最长公共子序列长度为4,最长公共子序列为'eood'

    该算法的空间、时间复杂度均为O(n^2)} O(n^2)。经过优化后,空间复杂度可为 O(n),时间复杂度可为O(nlogn)。
    注:最长公共子序列不要求序列连续

    python代码:

    UP_LEFT = 0		#左上
    UP = 1			#上
    LEFT = 2		#左
    
    def LCSlength(X,Y):
        '''
        输入:序列X和序列Y
        输出:X和Y的最长公共子序列长度
        '''
        #定义f数组,每行n个元素,每列m个元素
        m = len(X)
        n = len(Y)
        #lf = (lambda x,y:x+1 if x>y else y+1)
        #size = lf(m,n)
        f = [[0 for x in range(n+1)] for y in range(m+1)]
        #定义路径数组
        path = [[-1 for x in range(n+1)] for y in range(m+1)]
    
        for i in range(1,m+1):
            for j in range(1,n+1):
                if(X[i-1] == Y[j-1]):
                   f[i][j] = f[i-1][j-1]+1
                   path[i][j] = UP_LEFT
                else:
                   #f[i][j] = max(f[i-1][j],f[i][j-1])
                    if(f[i-1][j]>f[i][j-1]):
                        f[i][j] = f[i-1][j]
                        path[i][j] = UP
                    else:
                        f[i][j] = f[i][j-1]
                        path[i][j] = LEFT
        return f[m][n],path
    
    def getpath(path,X,i,j,arr):
        '''
            回溯求子序列
            输入:path,二维数组,路径信息
                X,原始序列
                i,j ,递归下标
                arr,存储结果元素
        '''
        if(i==0 or j ==0):
            return
        elif(path[i][j] == UP_LEFT):
            getpath(path,X,i-1,j-1,arr)
            arr.append(X[i-1])
        elif(path[i][j]==UP):
            getpath(path,X,i-1,j,arr)
        elif(path[i][j]==LEFT):
            getpath(path,X,i,j-1,arr)
        else:
            pass
            
    
    X=[1,3,1,4,5]
    Y=[1,1,1,4,5]
    
    #X = 'helloword'
    #Y = 'eoskod'
        
    arr = []
    length,path = LCSlength(X,Y)
    getpath(path,X,len(X),len(Y),arr)
    print(length)
    print(arr)

    看到网上还有将之转化成最长上升序列算法求解,思路是转化为最长上升子序列,并采用二分搜索,这种方法可以把平均时间复杂度降到nlogn,但是存在极端情况效率比普通的动态规划方法效率更低。先留个坑,后再研究,睡觉zzz

    参考:

    https://blog.csdn.net/v_JULY_v/article/details/6110269#commentsedit

    https://zh.wikipedia.org/wiki/%E6%9C%80%E9%95%BF%E5%85%AC%E5%85%B1%E5%AD%90%E5%BA%8F%E5%88%97

    展开全文
  • 关于最长公共子序列的知识和概念请大家参考这篇博文,因为时间问题,这里只写了代码实现。使用python3.5链接地址:点击打开链接 import numpy as np x=input() y=sorted(x) n=len(x) c=np.zeros((n+1,n+1),dtype=int...

    关于最长公共子序列的知识和概念请大家参考这篇博文,因为时间问题,这里只写了代码实现。使用python3.5

    链接地址:点击打开链接

    import numpy as np
    x=input()
    y=sorted(x)
    n=len(x)
    c=np.zeros((n+1,n+1),dtype=int)
    b=np.zeros((n+1,n+1),dtype=int)
    def LIS(x,y):
        for i in range(1,n+1):
            for j in range(1,n+1):
                if x[i-1]==y[j-1]:
                    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
        return b,c
    def PRINT_LIS(b,x,i,j):
        if i==0 or j==0:
            return
        if b[i,j]==1:
            PRINT_LIS(b,x,i-1,j-1)
            print(x[i-1])
        elif b[i,j]==2:
            PRINT_LIS(b,x,i,j-1)
        else:
            PRINT_LIS(b,x,i-1,j)
    LIS(x,y)
    PRINT_LIS(b,x,n,n)
    
     

    展开全文
  • DP算法:最长公共子序列:把问题分成两种情况来讨论:1. 如果S1[i] == S2[j]。就是i,j对应位置上的字符相等。那么可以得出M[i,j] = M[i-1,j-1]+1;为什么呢?可以想象的。如果M[i-1,j-1]也是一个最后方案,在这个最优...
  • 最长公共子序列python实现,最长公共子序列是动态规划基本题目,下面按照动态规划基本步骤解出来。 1.找出最优解的性质,并刻划其结构特征 序列a共有m个元素,序列b共有n个元素,如果a[m-1]==b[n-1],那么a[:m]和b[:...
  • 1. 最长公共子序列 1.1 问题描述 1.2 思路 利用动态规划。 下一步就要找到状态之间的转换方程。
  • 如何求最长公共子序列的长度相信大家都很熟悉,但是如何求出最长公共子序列的所有可能结果呢?接下来,就让小编带大家了解一下小编使用的方法吧。 问题描述: 我们先给定两个序列,以这个为例,求出它们最长公共子...
  • Python实现动态规划中最长公共子序列和最长公共子串问题!
  • Is there a built-in function in python which returns a length of longest common subsequence of two lists?a=[1,2,6,5,4,8]b=[2,1,6,5,4,4]print a.llcs(b)>>> 3I tried to find longest common subse...
  • 最长公共子序列问题 令A=a1,a2…an, B=b1,b2…bm, L[i, j]表示a1,a2…ai和b1,b2…bj的最长公共子序列长度。那么最重要的就是LCS(Longest Common Subsequence)的递推公式: 算法的伪代码如下所示: 算法的...
  • 《算法图解》第9章 动态规划 后面给出了怎么求两个字符串的 最长公共字串 和 最长公共子序列 的算法思路。但是没有给出代码实现,这里根据其思路实现其算法python编程。 最长公共字串 为两个字符串a, b中相同的连续...
  • 动态规划经典例题——最长公共子序列和最长公共子串(python) 很久之前大概是高中的时候写过这种题目,使用动态规划的方法求解的,现读研究生了,要把过去的拾起来的呢。 1. 最长公共子序列(LCS) 1.1 问题描述 ...
  • 最长公共子序列 空间复杂度为O(min(a,b))+1 记录左上角值""" if len(a) < len(b): a, b = b, a print(a, b) list = [0 for i in range(len(b))] for i in range(len(a))...
  • 主要介绍了详解Python最长公共子串和最长公共子序列的实现。小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 最长公共子序列 最长公共子串 最长递增序列 最长上升子序列-leetcode 给定一个序列,找出其中最长的,严格递增的子序列的长度(不要求连续)。 解法一:动态规划 通过一个辅助数组记录每一个元素处的最大序列...
  • 最长公共子序列 Description 给定两个字符串,返回两个字符串的最长公共子序列(不是最长公共子字符串),可能是多个。 Input 输入第一行为用例个数, 每个测试用例输入为两行,一行一个字符串 Output 如果没有公共...
  • python实现编辑距离 python实现最大公共子序列 python实现最长公共子串
  • 参考 http://blog.csdn.net/u012102306/article/details/53184446 ... 最长公共子序列LCS 动态规划状态转移方程式 Python 递归 def LCS(a, b): if a == '' or b == ...
  • python 最长公共子序列

    2021-08-27 10:54:55
    b[i][j] = 1 x[i]和y[j]的最长公共子序列是由x[i-1]和y[j-1]的最长公共子序列在尾部加上x[i]得到(打印,朝左上方找) b[i][j] = 2x[i]和y[j]的最长公共子序列与x[i-1]和y[j]的最长公共子序列相同(朝上面找) b[i...
  • 最长公共子序列问题Python实现

    千次阅读 2017-10-14 19:36:23
    最长公共子序列问题 问题介绍 最长公共子序列(LCS)是一个在一个序列集合中(通常为两个序列)用来查找所有序列中最长子序列的问题。一个数列 ,如果分别是两个或多个已知数列的子序列,且是所有符合此条件序列...
  • 最长公共子序列Python实现

    千次阅读 2014-05-26 13:38:27
    1 最长公共子序列问题描述 一个给定序列的子序列是在该序列中删除若干元素后得到的序列,确切的说,若给定序列X = {x1,x2,...xm},则另一个序列,Y= {y1,y2...,yn},当另一个序列即是X的子序列又是Y的子序列时,称Z是...
  • 最长公共子序列 & 最长公共子串的区别: 找两个字符串的最长公共子串,这个子串要求在原字符串中是连续的。而最长公共子序列则并不要求连续。 leetcode 1143题 最长公共子序列 !!!字符可以不连续 给定两个...
  • 最长公共子序列(python) 给定两个字符串 text1 和 text2,返回这两个字符串的最长公共子序列的长度。 一个字符串的 子序列 是指这样一个新的字符串:它是由原字符串在不改变字符的相对顺序的情况下删除某些字符(也...
  • 最长公共子序列:给定两个字符串A和B,长度分别为m和n,要求找出它们最长的公共子序列,并返回其长度。 解题思路:定义dp[i][j]为字符串A的第一个字符到第i个字符串(A[:i])和字符串B的第一个字符到第j个字符(B[:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,970
精华内容 1,188
关键字:

最长公共子序列python

python 订阅