算法55----最长子序列【动态规划】

最新推荐文章于 2023-03-30 21:55:32 发布

weixin_34259232

最新推荐文章于 2023-03-30 21:55:32 发布

阅读量160

点赞数 1

文章标签：数据结构与算法

原文链接：http://www.cnblogs.com/Lee-yl/p/9975827.html

版权

一、题目：最长公共子序列：

给定两个字符串，求解这两个字符串的最长公共子序列（Longest Common Sequence）。比如字符串L：BDCABA；字符串S：ABCBDAB

则这两个字符串的最长公共子序列长度为4，最长公共子序列是：BCBA

思路：动态规划：时间O(n * m)，空间O(n * m)

创建 DP数组C[i][j]：表示子字符串L【：i】和子字符串S【：j】的最长公共子序列个数。

状态方程：

个数代码：

def LCS(L,S):
    if not L or not S:
        return ""
    dp = [[0] * (len(L)+1) for i in range(len(S)+1)]
    for i in range(len(S)+1):
        for j in range(len(L)+1):
            if i == 0 or j == 0:
                dp[i][j] = 0
            else:
                if L[j-1] == S[i-1]:
                    dp[i][j] = dp[i-1][j-1] + 1
                else:
                    dp[i][j] = max(dp[i-1][j],dp[i][j-1])
    return dp[-1][-1]
L = 'BDCABA'
S = 'ABCBDAB'
LCS(L,S)

最长子序列代码：设置一个标志

def LCS(L,S):
    if not L or not S:
        return ""
    res = ''
    dp = [[0] * (len(L)+1) for i in range(len(S)+1)]
    flag = [['left'] * (len(L)+1) for i in range(len(S)+1)]
    for i in range(len(S)+1):
        for j in range(len(L)+1):
            if i == 0 or j == 0:
                dp[i][j] = 0
                flag [i][j] = '0'
            else:
                if L[j-1] == S[i-1]:
                    dp[i][j] = dp[i-1][j-1] + 1
                    flag[i][j] = 'ok'
                else:
                    dp[i][j] = max(dp[i-1][j],dp[i][j-1])
                    flag[i][j] = 'up' if dp[i][j] == dp[i-1][j] else 'left'
    return dp[-1][-1],flag
def printres(flag,L,S):
    m = len(flag)
    n = len(flag[0])
    res = ''
    i , j = m-1 , n-1
    while i > 0 and j > 0:
        if flag[i][j] == 'ok':
            res += L[j-1]
            i -= 1
            j -= 1
        elif flag[i][j] == 'left':
            j -= 1
        elif flag[i][j] == 'up':
            i -= 1
    return res[::-1]            
L = 'BDCABA'
S = 'ABCBDAB'
num,flag = LCS(L,S)
res = printres(flag,L,S)

二、题目：最长递增子序列

给定一个长度为N的数组，找出一个最长的单调自增子序列（不一定连续，但是顺序不能乱）。例如：给定一个长度为6的数组A{5， 6， 7， 1， 2， 8}，则其最长的单调递增子序列为{5，6，7，8}，长度为4.

解法一：最长公共子序列：O（N^2）

这个问题可以转换为最长公共子序列问题。如例子中的数组A{5，6， 7， 1， 2， 8}，则我们排序该数组得到数组A‘{1， 2， 5， 6， 7， 8}，然后找出数组A和A’的最长公共子序列即可。显然这里最长公共子序列为{5, 6, 7, 8}，也就是原数组A最长递增子序列。

解法二：动态规划法（时间复杂度O(N^2))

设 dp(j) 表示L中以 L[j] 为末元素的最长递增子序列的长度。状态方程：

dp(j) = { max(dp(i)) + 1, i<j且L[i]<L[j] }

这个递推方程的意思是，在求以L【j】为末元素的最长递增子序列时，找到所有序号在 j 前面且小于L【j】的元素L【i】，即 i < j 且 L【j】< L【i】。

例如给定的数组为{5，6，7，1，2，8}，则 dp(0)=1, dp(1)=2, dp(2)=3, dp(3)=1, dp(4)=2, dp(5)=4。所以该数组最长递增子序列长度为4，序列为{5，6，7，8}。

代码：

def LCS1(L):
    if not L:
        return ""
    dp = [1] * len(L)
    for j in range(len(L)):
        for i in range(j):
#当j = 5,i = 0时,dp = [1,2,3,1,2,1]
#当j = 5,i = 0时，dp[5] = 1 < dp[0]+1，故dp(5)更新为dp[0]+1=2，
#当j = 5,i = 1时，dp[5] = 2 < dp[1]+1 =3,故dp(5)更新为dp[1]+1=3
#当j = 5,i = 2时，dp[5] = 4
#当j = 5,i = 3时，dp[5] = 4 > dp[3]+1 = 3,故dp[5]不更新，同理，i = 4时，dp[5]仍等于4
            if L[j] > L[i] and dp[j] < dp[i] + 1:

                dp[j] = dp[i]+1
    return max(dp)
L = [5,6,7,1,2,8]
LCS1(L)

得到dp数组之后找出，最长递增子序列，

先找到dp最大值5，索引为7，然后arr【7】= 9
dp【6】 = 5-1 =4，故arr【6】=8
dp【4】 = 4-1或者dp【5】 = 4-1，故arr【4】 = 6 / arr【5】=4
dp 【2】=3-1或者dp【3】 = 3-1，故arr【2】 = 5 / arr【3】=3
2 / 1

故最长递增子序列：2→5→6→8→9或者1→3→4→8→9

解法三：优化的动态规划，时间O（NlogN），空间效率最坏情况也是O(n),

5 9 4 1 3 7 6 7 2

那么：dp为以下情况，

5 //加入
5 9 //加入
4 9 //用4代替了5
1 9 //用1代替4
1 3 //用3代替9
1 3 7 //加入
1 3 6 //用6代替7
1 3 6 7 //加入

1 2 6 7 //用2代替3

该dp=【1，2，6，7】数组理解为到目前为止长度为1的递增子序列末尾最小为1，长度为2的递增子序列末尾最小为2，长度为3的递增子序列末尾最小为6，长度为4的递增子序列末尾最小为7.

而2代替3是找到比刚好2大的数3，这个查找过程通过二分查找，故时间复杂度为二分查找的O（NlogN）

最后b中元素的个数就是最长递增子序列的大小，即4。

要注意的是最后数组里的元素并不就一定是所求的序列，

例如如果输入 2 5 1

那么最后得到的数组应该是 1 5

而实际上要求的序列是 2 5

进阶题目：二维数组的最长递增子序列（生日礼物（京东2016实习生真题））

把卡片套装在一系列的信封A = {a1, a2, ..., an}中。小东已经从商店中购买了很多的信封，她希望能够用手头中尽可能多的信封包装卡片。为防止卡片或信封被损坏，只有长宽较小的信封能够装入大些的信封，同尺寸的信封不能套装，卡片和信封都不能折叠。

解题思路：

　　我们首先定义一个结构体，存放信封的长，宽，及其索引位置，然后把不能装卡片的信封去除掉(长宽较小的)，然后根据长或宽进行一个排序，这样就可以转化成一个最长递增子序列问题来求解了，2层循环动态规划就很容易求解了。

三、题目：最长递增子序列个数

给定一个未排序的整数数组，找到最长递增子序列的个数。

示例 1:

输入: [1,3,5,4,7]
输出: 2
解释: 有两个最长递增子序列，分别是 [1, 3, 4, 7] 和[1, 3, 5, 7]。

示例 2:

输入: [2,2,2,2,2]
输出: 5
解释: 最长递增子序列的长度是1，并且存在5个子序列的长度为1，因此输出5。

注意: 给定的数组长度不超过 2000 并且结果一定是32位有符号整数。

思路：动态规划，时间O（n2)，空间O（n2)

定义 dp(n,1) count (n,1)

用dp[i]表示以nums[i]为结尾的递推序列的长度，

用cnt[i]表示以nums[i]为结尾的递推序列的个数，

初始化都赋值为1，只要有数字，那么至少都是1。

状态方程：

if nums[i] > nums[j] and dp[i] == dp[j] :
dp[i] = dp[j]+1

　　count[i] = count[j]

elif nums[i] > nums[j] and dp[i] == dp[j]+1:

　　count[i] += count[j]

代码：

def findNumberOfLIS(nums):
    # dp solution, 2 arrays
    # dp[i] stores the longest length ending at nums[i]
    # count[i] counts the number of paths with length dp[i]
    if not nums:
        return 0

    n = len(nums)
    dp = [1] * n
    count  = [1] * n

    for i in range(1, n):
        for j in range(i):
            if nums[i] > nums[j]:
                # dp[i] = max(dp[j]+1, dp[i]) 
                # but we need to compute count also
                if dp[i] == dp[j]:
                    dp[i] = dp[j]+1
                    count[i]  = count[j]
                elif dp[i] == dp[j]+1:
                    count[i] += count[j]

    maxLength = max(dp)
    return sum([count[i] for i in range(n) if dp[i] == maxLength])
nums = [1,3,5,4,6]
findNumberOfLIS(nums)

四、题目：最大连续子序列（子串）

最大子序列是要找出由数组成的一维数组中和最大的连续子序列。比如{5,-3,4,2}的最大子序列就是 {5,-3,4,2}，它的和是8,达到最大；而 {5,-6,4,2}的最大子序列是{4,2}，它的和是6。你已经看出来了，找最大子序列的方法很简单，只要前i项的和还没有小于0那么子序列就一直向后扩展，否则丢弃之前的子序列开始新的子序列，同时我们要记下各个子序列的和，最后找到和最大的子序列。

import copy
def maxSubSum(arr):
    if not arr:
        return 0
    maxSum,curSum = 0,0
    SubList,curlist = [],[]
    for i in range(len(arr)):
        if curSum + arr[i] > 0:
            curSum += arr[i]
            maxSum = curSum
            curlist.append(arr[i])
            SubList = copy.deepcopy(curlist)
        else:
            curSum = 0
            curlist = []
    return maxSum,SubList
arr = [5,-6,4,2,-1,3,-9]
maxSubSum(arr)

五、题目：最长公共子串

找出两个字符串最长连续的公共字符串，如两个母串cnblogs和belong，最长公共子串为lo

思路：动态规划：时间O（N*M),空间O(N*M)

将二维数组c[i][j]用来记录具有这样特点的子串——结尾同时也为子串x1x2⋯xi与y1y2⋯yj的结尾的长度。

代码：

def lcs(s1,s2):
    if not s1 or not s2:
        return 0
    c = [[0] * len(s2) for i in range(len(s1))]
    result = 0
    for i in range(len(s1)):
        for j in range(len(s2)):
            if i == 0 or j == 0:
                c[i][j] = 0
            else:
                if s1[i-1] == s2[j-1]:
                    c[i][j] = c[i-1][j-1] + 1
                    result = max(c[i][j],result)
                else:
                    c[i][j] = 0
    return result
s1 = 'cnblogs'
s2 ='belong'
lcs(s1,s2)

六、题目：最长公共子序列（3个字符串）

设A、B、C是三个长为n的字符串，它们取自同一常数大小的字母表。设计一个找出三个串的最长公共子序列的O(n^3)的时间算法。
思路：跟上面的求2个字符串的公共子序列是一样的思路，只不过这里需要动态申请一个三维的数组，三个字符串的尾字符不同的时候，考虑的情况多一些而已。

七、题目：判断s是否为t的子序列：

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

你可以认为 s 和 t 中仅包含英文小写字母。字符串 t 可能会很长（长度 ~= 500,000），而 s 是个短字符串（长度 <=100）。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

示例 1:
s = "abc", t = "ahbgdc"

返回 true.

示例 2:
s = "axc", t = "ahbgdc"

返回 false.

后续挑战 :

如果有大量输入的 S，称作S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

思路：动态规划：dp[i]表示：s[i] 是否在t中，在则True，不在则False。

初始化：dp = [False] * len(s)

状态方程：if s[i] == t[j]，则dp[i] = True, i+=1,j += 1，否则，j+=1【继续找，直到找到t的尾部】

代码：

    def isSubsequence(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        if not s:
            return True
        if not t or len(s) > len(t):
            return False
        i , j = 0 , 0
        dp = [False] * len(s)
        while i < len(s) and j < len(t):
            if s[i] == t[j]:
                dp[i] = True
                i += 1
                j += 1
            else:
                j += 1
        return all(dp)

八、题目：平方串

如果一个字符串S是由两个字符串T连接而成,即S = T + T, 我们就称S叫做平方串,例如"","aabaab","xxxx"都是平方串.
牛牛现在有一个字符串s,请你帮助牛牛从s中移除尽量少的字符,让剩下的字符串是一个平方串。换句话说,就是找出s的最长子序列并且这个子序列构成一个平方串。

思路：动态规划：时间O（n^3），空间O（n^2)

首先将字符串s分为s1和s2，求s1和s2最长公共子序列。

拆分s1和s2有n种，如s = ‘ frankfurt'，一、s1 = 'f'，s2='rankfurt'。二、s1 ='fr'，s2 = ’ankfurt‘……

故该方法时间复杂度为n3

代码：

def test():
    s = input()
    res = 0
    for i in range(len(s)-1):
        res = max(res,lcs(s,i))
    return 2*res
def lcs(s,i):
    s1 = s[:i+1]
    s2 = s[i+1:]
    dp = [[0] * (len(s2)+1) for i in range(len(s1)+1)]
    for i in range(1,len(s1)+1):
        for j in range(1,len(s2)+1):
            if s1[i-1] == s2[j-1]:
                dp[i][j] = dp[i-1][j-1] + 1
            else:
                dp[i][j] = max(dp[i-1][j],dp[i][j-1])
    return dp[-1][-1]
if __name__ == '__main__':
    print(test())

九、题目：乘积最大子序列

给定一个整数数组 nums ，找出一个序列中乘积最大的连续子序列（该序列至少包含一个数）。

示例 1:

输入: [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。

示例 2:

输入: [-2,0,-1]
输出: 0
解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。

思路：设置两个变量，一个存储当前最大值，一个存储最小值。

访问到每个点的时候，以该点为子序列的末尾的乘积，要么是该点本身，要么是该点乘以以前一点为末尾的序列，注意乘积负负得正，故需要记录前面的最大最小值。

代码：

def test(nums):
    if not nums:
        return 0
    minnum = nums[0]
    maxnum = nums[0]
    res = nums[0]
    for i in range(1,len(nums)):
        minnum = min([nums[i],minnum*nums[i],maxnum*nums[i]])
        maxnum = max([nums[i],maxnum*nums[i],minnum*nums[i]])
        res = max(res,maxnum)
    return res
nums = [2,3,-2,4]
test(nums)

转载于:https://www.cnblogs.com/Lee-yl/p/9975827.html

weixin_34259232

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
算法55----最长子序列【动态规划】

一、题目：最长公共子序列：给定两个字符串，求解这两个字符串的最长公共子序列（Longest Common Sequence）。比如字符串L：BDCABA；字符串S：ABCBDAB则这两个字符串的最长公共子序列长度为4，最长公共子序列是：BCBA思路：动态规划：时间O(n * m)，空间O(n * m)创建 DP数组C[i][j]：表示子字符串L【：i】和子字符串S【：j】的最长公共...
复制链接

扫一扫