2. 程式人生 > >動態規劃演算法--解最長公共子序列問題

動態規劃演算法--解最長公共子序列問題

阿新 • • 發佈：2019-02-17

如今最好，沒有來日方長！

一、簡述動態規劃演算法

1.動態規劃演算法簡介

（1）背景

動態規劃(英語：Dynamic programming，簡稱：DP)是一種演算法設計技術，是運籌學的一個分支，是求解決策過程(Decision process)最優化的數學方法。值得注意的是，這個技術名字中的“programming”是計劃和規劃的意思，不是計算機領域中的程式設計。它有著有趣的歷史。
它由20世紀50年代初美國一位卓越的數學家Richard Bellman所發明。數學家們在研究多階段決策過程(multistep decision process)的優化問題時，提出了著名的最優化原理(principle of optimality)，把多階段過程轉化為一系列單階段問題逐個求解，創立了解決這類過程優化問題的新方法——動態規劃。

（2）基本思想

動態規劃演算法通常用於求解最優決策的問題。其基本思想是基於初始狀態，將待求解問題分解成若干個子問題，其中當前子問題的解由上一次子問題的解推出，然後從這些子問題的解得到原問題的解。具體的動態規劃演算法有很多種，它們都用一個表來記錄所有已解子問題的答案，以此避免重複計算，而節約時間。

（3）例項分析理解

這裡寫圖片描述
這裡寫圖片描述
假設情景：某一天中午起床晚了，十二棟到惟義樓w7504的路
路線很多，只有走最短路線才能避免遲到。路線及所花時間，如上圖所示，求解最短路線
應用動態規劃演算法的理解：將該過程分為A.B.C.D四階段，每個階段中，都求出本階段的各個初始狀態到過程終點的最短路徑和最短距離，逆序倒推到起點十二棟時，便得到十二棟到教室的最短路徑及最短距離。

2.演算法特點

顯而易見，動態規劃演算法可以很好的求解最優化問題。可以有效地解決冗餘，降低原來具有指數級複雜度演算法的時間複雜度。
最大的特點就是可以求得最優策略，符合最優化原理，即“最優策略的子策略也是最優策略”。
但是，任何思想方法都有一定的侷限性。
因此，動態規劃也有一些適用條件，即：適用動態規劃的問題必須滿足最優化原理和無後效性。簡單說明，最優化原理即：一個最優化策略的子策略總是最優的；無後向性即：每個階段的歷史狀態無法直接影響它的未來決策，只能通過當前的這個狀態做出決策。例如，我在階段B的某位置，階段C“圖書館”以及“二食堂”的位置不會影響我選擇哪條路。

3.動態規劃演算法應用

動態規劃演算法普遍在數學、經濟學、電腦科學中使用。在最優控制、生產排程、機器學習等方面得到了廣泛的應用。例如最短路線、庫存管理、資源分配、裝置更新、排序、揹包問題、影象資料壓縮、手勢識別、語音識別、資料探勘、資訊檢索以及最長公共子序列等應用問題。

二、問題求解

1.演算法設計與論證

採用動態規劃演算法思想求解最長公共子序列，先將問題分解成若干個子問題，再求解子問題的最優子策略，最後求解原問題的最優策略。

（1）基本概念

在分析最長公共子序列的最優子結構前，先清楚以下概念:
子序列：某個序列的子序列指從原序列中不破壞順序地任意除去若干個字元後形成的序列。
例：序列X，Y，其中X=“BABBCDB”，Y=“BDB”，則Y是X的一個子序列。

公共子序列：如果Z是X的子序列也是Y的子序列，那麼Z是序列X與Y的公共子序列

最長公共子序列結構性質：第i字首
如序列A=(a1,a2,…..,am)，則Ai=(a1,….,ai-1,ai)是序列A的第i字首。
例：A=(A,B,D,C,D),A1=(A),A2=(A,B),A3=(A,B,D)

（2）最優子結構

由最長公共子序列結構性質可分析得最優子結構，現如題，假設段落一為序列A=(a1,a2,…..,am)（設長度為m）,段落二為序列T=(t1,t2,…,tn)（設長度為n），A與T的最長公共子序列為S=(s1,s2,….,sk)（設長度為k）則：
若am=tn，則sk=am=tn且Sk-1是Am-1和Tn-1的最長公共子序列；
若am≠tn且sk≠am ，則S是Am-1和T的最長公共子序列；
若am≠tn且sk≠tn ，則S是A和Tn-1的最長公共子序列
根據最長公共子序列的最優子結構可知，當am=tn時，A,T的最長公共子序列即Am-1和Tn-1的最長公共子序列加上am，當am≠tn時，A,T的最長公共子序列即Am-1和T的最長公共子序列或者A和Tn-1的最長公共子序列，則A和T的最長公共子序列為這兩個最長公共子序列的最長者。
因此，求解A,T的最長公共子序列問題，均包括子問題，求解Am-1,Tn-1的最長公共子序列。

（3）最優值

由最長公共子序列的最優子結構得最長公共子序列最優值，可建立如下公式，用c[i,j]表示序列Ai和Tj的最長公共子序列的長度，則：
c[i,j] = 0, i=0或j=0
c[i,j] = c[i-1,j-1]+1, ai=tj
c[i,j] = max(c[i,j-1],c[i-1,j], ai≠tj

虛擬碼：

Description:The longest common sub-sequence problem . 
Init: m,d {m,d:(L1+1)(L2+1)的0矩陣}
Input: s1,s2,L1,L2
Function LCS(s1,s2)
L1=length[s1];L2=length[s2]
FOR p1=1 TO L1
FOR p2=1 TO L2
            IF  s1[p1] == s2[p2]                             
m[p1+1][p2+1] = m[p1][p2]+1  
           d[p1+1][p2+1] = 1           
        IF m[p1][p2+1] >= m[p1+1][p2]                
m[p1+1][p2+1] = m[p1][p2+1]   
            d[p1+1][p2+1] = 2           
        ELSE                                        
        m[p1+1][p2+1] = m[p1+1][p2]     
            d[p1+1][p2+1] = 3           
            ENDIF
         ENDIF
    ENDFOR 
ENDFOR 
Output: m,d

程式碼實現：

import numpy as np
#np.set_printoptions(threshold = 1e6)#設定列印數量閾值，避免列印省略號
def LCS(s1, s2):   
    # 序列長度加1的0矩陣
    # m用來儲存對應位置匹配的結果  
    m = [ [ 0 for x in range(len(s2)+1) ] for y in range(len(s1)+1) ]   
    # d用來記錄回溯矩陣 
    d = [ [ 0 for x in range(len(s2)+1) ] for y in range(len(s1)+1) ]   
    for p1 in range(len(s1)):   
        for p2 in range(len(s2)):   
            if s1[p1] == s2[p2]:              #匹配成功，取左上方的值加1，並標記回溯數字1  
                m[p1+1][p2+1] = m[p1][p2]+1  
                d[p1+1][p2+1] = 1           
            elif m[p1][p2+1] >= m[p1+1][p2]:  #左邊值大於上邊值，則取左值，並標記回溯數字2  
                m[p1+1][p2+1] = m[p1][p2+1]   
                d[p1+1][p2+1] = 2           
            else:                             #上值大於左值，則該位置的值為上值，並標記回溯數字3
                m[p1+1][p2+1] = m[p1+1][p2]     
                d[p1+1][p2+1] = 3         
    p1, p2 = len(s1), len(s2)
    print(m[p1][p2])
    #print(np.array(m))                        #列印對應位置匹配矩陣
    #print (np.array(d))                       #列印回溯矩陣 
    #回溯 構造最長公共子序列
    s = ''                  #儲存最長公共子序列
    while m[p1][p2]:        #不為0時  
        c = d[p1][p2]
        if c == 1:          #匹配成功，插入1，並向左上角找下一個  
            s=s1[p1-1]+s
            p1-=1  
            p2-=1   
        if c ==2:           #根據標記，向左找下一個  
            p1 -= 1  
        if c == 3:          #根據標記，向上找下一個  
            p2 -= 1    
    return s

具體演算法語言描述：
用矩陣記錄兩個基因序列的匹配程度，如果匹配則左上方的數字+1，否則取左邊和上邊的最大值，如果左邊值大於上邊值，則取左邊值並標記回溯數字“3”，如果上邊值大於左邊值，則取上邊值並標記回溯數字“2”，如果左邊值等於上邊值，則取上邊值並標記回溯數字“2”。

測試：

if __name__ == '__main__':   

    x = 'ACAAGATGCCATTGTCC'
    y = 'TATAAATGTGTACA'
    print(LCS(x,y))

匹配矩陣：

[[ 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0]
 [ 0  0  1  1  1  1  1  1  1  1  1  1  1  1  1]
 [ 0  0  1  1  1  1  1  1  1  1  1  1  1  2  2]
 [ 0  0  1  1  2  2  2  2  2  2  2  2  2  2  3]
 [ 0  0  1  1  2  3  3  3  3  3  3  3  3  3  3]
 [ 0  0  1  1  2  3  3  3  4  4  4  4  4  4  4]
 [ 0  0  1  1  2  3  4  4  4  4  4  4  5  5  5]
 [ 0  1  1  2  2  3  4  5  5  5  5  5  5  5  5]
 [ 0  1  1  2  2  3  4  5  6  6  6  6  6  6  6]
 [ 0  1  1  2  2  3  4  5  6  6  6  6  6  7  7]
 [ 0  1  1  2  2  3  4  5  6  6  6  6  6  7  7]
 [ 0  1  2  2  3  3  4  5  6  6  6  6  7  7  8]
 [ 0  1  2  3  3  3  4  5  6  7  7  7  7  7  8]
 [ 0  1  2  3  3  3  4  5  6  7  7  8  8  8  8]
 [ 0  1  2  3  3  3  4  5  6  7  8  8  8  8  8]
 [ 0  1  2  3  3  3  4  5  6  7  8  9  9  9  9]
 [ 0  1  2  3  3  3  4  5  6  7  8  9  9 10 10]
 [ 0  1  2  3  3  3  4  5  6  7  8  9  9 10 10]]

回溯矩陣

[[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
 [0 2 1 3 1 1 1 3 3 3 3 3 1 3 1]
 [0 2 2 2 2 2 2 2 2 2 2 2 2 1 3]
 [0 2 1 2 1 1 1 3 3 3 3 3 1 2 1]
 [0 2 1 2 1 1 1 3 3 3 3 3 1 3 1]
 [0 2 2 2 2 2 2 2 1 3 1 3 3 3 3]
 [0 2 1 2 1 1 1 3 2 2 2 2 1 3 1]
 [0 1 2 1 2 2 2 1 3 1 3 1 2 2 2]
 [0 2 2 2 2 2 2 2 1 3 1 3 3 3 3]
 [0 2 2 2 2 2 2 2 2 2 2 2 2 1 3]
 [0 2 2 2 2 2 2 2 2 2 2 2 2 1 2]
 [0 2 1 2 1 1 1 2 2 2 2 2 1 2 1]
 [0 1 2 1 2 2 2 1 2 1 3 1 2 2 2]
 [0 1 2 1 2 2 2 1 2 1 2 1 3 3 2]
 [0 2 2 2 2 2 2 2 1 2 1 2 2 2 2]
 [0 1 2 1 2 2 2 1 2 1 2 1 3 3 3]
 [0 2 2 2 2 2 2 2 2 2 2 2 2 1 3]
 [0 2 2 2 2 2 2 2 2 2 2 2 2 1 2]]

最長公共子序列及長度：

10
AAAATGTGTC

也可以用來檢測文件間的匹配度，只需要增加以下內容即可：

def loadData(filename):
    import jieba
    txt = open(filename).read()
    for char in '！，。·~、？‘；“：”+-|、||《》{}【】&*（）-&……%':
        words = jieba.lcut(txt)
        words = txt.replace(char," ")     #噪聲處理，將特殊字元替換為空格

    return words


if __name__ == '__main__': 
    txt1 = loadData('三生三世十里桃花.txt')
    txt2 = loadData('桃花債.txt')
    print(LCS(txt2,txt1))

三、演算法複雜度分析及優化

對於一個具體的問題，設計與分析得出的演算法，往往考慮兩點，一即演算法正確性；二即演算法的時間及空間複雜度。

動態規劃演算法求最長公共子序列問題的時間複雜度為和空間複雜度均為：Ο(mn)

常見的演算法時間複雜度由小到大依次為：Ο(1)＜Ο(log2n)＜Ο(n)＜O(nlog2n)＜Ο(n²)＜Ο(n³)＜…＜Ο(2ⁿ)＜Ο(n!)
則Ο(n²)＜Ο(mn)<Ο(n³)，如下圖所示，當n越大所需時間隨指數級增長。
這裡寫圖片描述

複雜度與計算時間關係如下圖，雖然動態規劃演算法有效地降低了指數級增長的複雜度，但當資料較大時，複雜度仍舊遞增增長，查資料顯示可以將此問題時間複雜度降低到Ο(nlogn)，由於目前我的演算法優化程度不夠，所以，這裡提取《三生三世十里桃花》前三章的內容以及《桃花債》前十章的內容，進行求解其最長公共子序列的長度。

這裡寫圖片描述

去除矩陣d後優化程式碼如下：

import numpy as np
def LCS(s1, s2):   
    # 序列長度加1的0矩陣
    # m用來儲存對應位置匹配的結果  
    m = [ [ 0 for x in range(len(s2)+1) ] for y in range(len(s1)+1) ]     
    for p1 in range(len(s1)):   
        for p2 in range(len(s2)):   
            if s1[p1] == s2[p2]:              #匹配成功，取左上方的值加1  
                m[p1+1][p2+1] = m[p1][p2]+1             
            else:                             #取左邊值和上邊值的大值
                m[p1+1][p2+1] = max(m[p1+1][p2], m[p1][p2+1])    
    p1, p2 = len(s1), len(s2)
    return m[p1][p2]

def loadData(filename):
    import jieba
    txt = open(filename).read()
    words = jieba.lcut(txt) #讀取中文字元
    return words


if __name__ == '__main__': 
    txt1 = loadData('三生三世十里桃花.txt')
    txt2 = loadData('桃花債.txt')
    print(LCS(txt2,txt1))

四、總結

該演算法還可以進一步優化，如果演算法沒有進一步優化到對數級別上，最好不要嘗試100000的資料，會宕機的……

相關推薦

動態規劃演算法解最長公共子序列LCS問題

原文地址：http://blog.csdn.net/rrrfff/article/details/7523437 動態規劃演算法解LCS問題 作者 July 二零一零年十二月三十一日 本文參考：

動態規劃演算法--解最長公共子序列問題

如今最好，沒有來日方長！ 一、簡述動態規劃演算法 1.動態規劃演算法簡介 （1）背景 動態規劃(英語：Dynamic programming，簡稱：DP)是一種演算法設計技術，是運籌學的一個分支，是求解決策過程(Decision pr

Python 動態規劃演算法求解最長公共子序列

前言：在網上看到一道360的秋招真題，題目如下： 仔細讀題後發現這是一道求解最長公共子序列的問題，最好使用動態規劃演算法。 題目大意： 小B坐火車，從起點到終點的車站序列已知，期間他睡了兩覺，到終點的時候還在睡，也就是說中間他醒了兩次，這兩次清醒的時間，有兩個車站子序列，

演算法學習——動態規劃 例題：最長公共子序列問題（java）

題目： 給定兩個字串str1和str2,返回兩個字串的最長公共子序列.例如,str1="1A2C3D4B56",str2="B1D23CA45B6A","123456"或者"12C4B6' 動態規劃思想： 先用一個比，左邊加一個字元右面加一個字元依次比較dp[i][j] dp[i][j]意思

動態規劃：求最長公共子序列和最長公共子串

最長公共子序列（LCS）： 這同樣是一道經典題目，定義就不說了。 為了方便說明，我們用Xi代表{x1,x2,‥xi},用Yj代表{y1,y2,‥yj}。那麼，求長度分別為m，n的兩個序列X,Y的LCS就相當於求Xm與Yn的LCS。我們將其分割為區域性問題進行分析。 首先，求Xm與Yn的LCS要考慮一下兩

動態規劃專題之最長公共子序列

動態規劃系列專題講義 專題三：最長公共子序列 /* Name: 動態規劃專題之最長公共子序列 Author: 巧若拙 Description: 1808_公共子序列 描述：我們稱序列Z = < z1, z2, ..., zk >是序列X = < x1, x2,

【經典動態規劃問題】最長公共子序列LCS

目錄 題目 題目分析 狀態 邊界值討論 其他情況討論 程式碼實現 從題目出發分析如何用動態規劃求解最長公共子序列問題 題目 給定兩個字串A和B，返回兩個字串的最長公共子序列的長度。例如，A="1A2C3D4B56”，B="B1D23CA45B6A”，”1234

動態規劃入門之最長公共子序列（LCS）

LCS是動態規劃在字串問題中應用的典型。問題描述：給定2個序列，求這兩個序列的最長公共子序列，不要求子序列連續。例如{2,4,3,1,2,1}和{1,2,3,2,4,1,2}的結果是{2,3,2,1}或者{2,4,1,2}。 思路：如果不用動態規劃去做，而用暴力法，則必須找

【動態規劃】NYOJ最長公共子序列

最長公共子序列 時間限制：3000 ms  |  記憶體限制：65535 KB 難度：3 描述咱們就不拐彎抹角了，如題，需要你做的就是寫一個程式，得出最長公共子序列。 tip：最長公共子序

演算法導論-----最長公共子序列LCS（動態規劃）

目錄 一.概念梳理   1. 子序列(subsequence)： 一個特定序列的子序列就是將給定序列中零個或多個元素去掉後得到的結果(不改變元素間相對次序)。例如序列<A,B,C,B,D,A,B>的子序列有：<A,B>、&l

演算法學習——動態規劃 例題：最長遞增子序列（java）

給定陣列arr，返回arr的最長遞增子序列長度。比如arr=[2,1,5,3,6,4,8,9,7]最長遞增子序列為， [1,3,4,8,9] ,所以返回這個子序列的長度為5，給定陣列arr， 返回arr的最長所以返回這個子序列的長度。比如arr=[2,1,5,3,6,4,8,9,7] 最長遞增子序列

【動態規劃】求最長公共子串，最長迴文子串

題目 : 給定兩個字串，求出它們之間連續的最長的相同子字串的長度。 eg : fbaabe，ebaabf，連續最長子串長度為4。 注意：求最長迴文子串也可以用求最長公共子串來求，只需將字串反轉作為另外一個字串，迴文部分反轉之後不變，然後求LCS（Longes

【NOJ1540】【動態規劃_DP】最長遞增子序列的長度

1540.最長遞增子序列的長度 時限：1000ms 記憶體限制：10000K  總時限：3000ms 描述 給定一個序列，求它的最長遞增子序列的長度 輸入 先輸入一個正整數n，表示序列的長度，再輸入n個整數表示這個序列 輸出 輸出它的最長遞增子序列的長

[Java] 藍橋杯ADV-202 演算法提高 最長公共子序列

問題描述給定兩個字串，尋找這兩個字串之間的最長公共子序列。輸入格式輸入兩行，分別包含一個字串，僅含有小寫字母。輸出格式最長公共子序列的長度。樣例輸入abcdgh aedfhb樣例輸出3樣例說明最長公共子

動態規劃專題之最長上升子序列

專題四：最長上升子序列 /*        Name:動態規劃專題之最長上升子序列        Author:巧若拙     &

動態規劃基礎篇--最長上升子序列

今天我們要講的是最長上升子序列（LIS）。 【題目描述】 給定N個數，求這N個數的最長上升子序列的長度。 【樣例輸入】 7 2 5 3 4 1 7 6 【樣例輸出】 4 什麼是最長上升子序列？ 就是給你一個序列，請你在其中求出一段不斷嚴格上升的部分，它

動態規劃C++實現--最長遞增子序列

題目： 給定陣列arr, 返回arr的最長遞增子序列。舉例：arr = [2, 1, 5, 3, 6, 4, 8, 9, 7], 返回的最長遞增子序列為 [1, 3, 4, 8, 9]要求：如果arr長度為N，請實現時間複雜度為O(NlogN)的方法。目錄： 一、 時間複雜度

【經典動態規劃問題】最長上升子序列 LIS

目錄   最長上升子序列： O(N^2)動態規劃: O(N*logN)：貪心+二分 最長上升子序列： 一個數的序列bi，當b1 < b2 < … < bS的時候，我們稱這個序列是上升的。對於給定的一個序列(a1, a2, …, aN)，我們可以

演算法學習之二——用DP和備忘錄演算法求解最長公共子序列問題

問題定義： 最長公共子序列：給定兩個序列X={x1,x2,……xn},Y={y1,y2……,ym},如果X的子序列存在一個嚴格遞增的下標序列{,,……},使得對於所有的j=1,2……，k，有=，則稱產生的陣列為對應的公共子序列。 如果公共子序列的長度最大，我們就稱之為最長公

演算法實踐--最長公共子序列(Longest Common Subsquence)

什麼是最長公共子序列 X=ACCG Y=CCAGCA 長度為1的公共子序列: {A} {C} {G} 長度為2的公共子序列：{AC} {CC} {CG} {AG} 長度為3的公共子序列：{ACG} 長度為4的公共子序列   最長公共子序列即為 {ACG}   問題：長度