LCS 演算法：Javascript 最長公共子序列

發表於2018-01-23

最長公共子序列（Longest Common Subsequence LCS）是從給定的兩個序列X和Y中取出儘可能多的一部分字元，按照它們在原序列排列的先後次序排列得到。LCS問題的演算法用途廣泛，如在軟體不同版本的管理中，用LCS演算法找到新舊版本的異同處;在軟體測試中，用LCS演算法對錄製和回放的序列進行比較，在基因工程領域，用LCS演算法檢查患者DNA連與鍵康DNA鏈的異同;在防抄襲系統中，用LCS演算法檢查論文的抄襲率。LCS演算法也可以用於程式程式碼相似度度量，人體執行的序列檢索，視訊段匹配等方面，所以對LCS演算法進行研究具有很高的應用價值。

基本概念

子序列(subsequence)：一個特定序列的子序列就是將給定序列中零個或多個元素去掉後得到的結果(不改變元素間相對次序)。例如序列的子序列有：、、等。
公共子序列(common subsequence)：給定序列X和Y，序列Z是X的子序列，也是Y的子序列，則Z是X和Y的公共子序列。例如X=[A,B,C,B,D,A,B]，Y=[B,D,C,A,B,A[，那麼序列Z=[B,C,A]為X和Y的公共子序列，其長度為3。但Z不是X和Y的最長公共子序列，而序列[B,C,B,A]和[B,D,A,B]也均為X和Y的最長公共子序列，長度為4，而X和Y不存在長度大於等於5的公共子序列。對於序列[A,B,C]和序列[E,F,G]的公共子序列只有空序列[]。
最長公共子序列：給定序列X和Y，從它們的所有公共子序列中選出長度最長的那一個或幾個。
子串：將一個序列從最前或最後或同時刪掉零個或幾個字元構成的新系列。區別與子序列，子序列是可以從中間摳掉字元的。cnblogs這個字串中子序列有多少個呢？很顯然有27個，比如其中的cb,cgs等等都是其子序列

給一個圖再解釋一下：

我們可以看出子序列不見得一定是連續的，連續的是子串。

問題分析

我們還是從一個矩陣開始分析,自己推匯出狀態遷移方程。

首先，我們把問題轉換成前端夠為熟悉的概念，不要序列序列地叫了，可以認為是陣列或字串。一切從簡，我們就估且認定是兩個字串做比較吧。

我們重點留意”子序列“的概念，它可以刪掉多個或零個，也可以全部幹掉。這時我們的第一個子序列為空字串（如果我們的序列不是字串，我們還可以）！這個真是千萬要注意到！許多人就是看不懂《演算法導論》的那個圖表，還有許多部落格的作者不懂裝懂。我們總是從左到右比較，當然了第一個字串，由於作為矩陣的高，就垂直放置了。

X	“”	B	D	C	A	B	A
“”
A
B
C
D
A
B

假令X ＝ “ABCDAB”， Y＝”BDCABA”，各自取出最短的序列，也就是空字串與空字串比較。LCS的方程解為一個數字，那麼這個表格也只能填數字。兩個空字串的公同區域的長度為0.

X	“”	B	D	C	A	B	A
“”	0
A
B
C
D
A
B

然後我們X不動，繼續讓空字串出陣，Y讓“B”出陣，很顯然，它們的公共區域的長度為0. Y換成其他字元， D啊，C啊，或者，它們的連續組合DC、 DDC，情況沒有變，依然為0. 因此第一行都為0. 然後我們Y不動，Y只出空字任串，那麼與上面的分析一樣，都為0，第一列都是0.

X	B	D	C	A	B	A
“”	0	0	0	0	0	0
A
B
C
D
A
B

LCS問題與揹包問題有點不一樣，揹包問題還可以設定-1行，而最長公共子序列因為有空子序列的出現，一開始就把左邊與上邊固定死了。

然後我們再將問題放大些，這次雙方都出一個字元，顯然只有兩都相同時，才有存在不為空字串的公共子序列，長度也理解數然為1。

A為”X”, Y為”BDCA”的子序列的任意一個

X	B	D	C	A	B	A
“”	0	0	0	0	0	0
A	0	0	0	1
B
C
D
A
B

繼續往右填空，該怎麼填？顯然，LCS不能大於X的長度，Y的從A字串開始的子序列與B的A序列相比，怎麼也能等於1。

X	B	D	C	A	B	A
“”	0	0	0	0	0	0
A	0	0	0	1	1	1
B
C
D
A
B

如果X只從派出前面個字元A,B吧，亦即是“”，“A”, “B”, “AB”這四種組合，前兩個已經解說過了。那我們先看B，${X_1} == ${Y_0}，我們得到一個新的公共子串了，應該加1。為什麼呢？因為我們這個矩陣是一個狀態表，從左到右，從上到下描述狀態的遷移過程，並且這些狀態是基於已有狀態累加出來的。現在我們需要確認的是，現在我們要填的這個格子的值與它周圍已經填好的格子的值是存在何種關係。目前，資訊太少，就是一個孤點，直接填1。

X	B	D	C	A	B	A
“”	0	0	0	0	0	0
A	0	0	0	1	1	1
B	1
C
D
A
B

然後我們讓Y多出一個D做幫手，{“”,A,B,AB} vs {“”,B,D,BD}，顯然，繼續填1. 一直填到Y的第二個B之前，都是1。因為到BDCAB時，它們有另一個公共子序列，AB。

X	B	D	C	A	B	A
“”	0	0	0	0	0	0
A	0	0	0	1	1	1
B	1	1	1	1	2
C
D
A
B

到這一步，我們可以總結一些規則了，之後就是通過計算驗證我們的想法，加入新的規則或限定條件來完善。

Y將所有字元派上去，X依然是2個字元，經仔細觀察，還是填2.

看五行，X再多派一個C，ABC的子序列集合比AB的子序列集合大一些，那麼它與Y的B子序列集合大一些，就算不大，就不能比原來的小。顯然新增的C不能成為戰力，不是兩者的公共字元，因此值應該等於AB的子序列集合。

×	B	D	C	A	B	A
“”	0	0	0	0	0	0
A	0	0	0	1	1	1
B	1	1	1	1	2	2
C	1
D
A
B

並且我們可以確定，如果兩個字串要比較的字元不一樣，那麼要填的格子是與其左邊或上邊有關，那邊大就取那個。

如果比較的字元一樣呢，稍安毋躁，剛好X的C要與Y的C進行比較，即ABC的子序列集合{“”,A,B,C,AB,BC,ABC}與BDC的子序列集合｛””,B,D,C,BD,DC,BDC｝比較，得到公共子串有“”,B,D 。這時還是與之前的結論一樣，當字元相等時，它對應的格子值等於左邊與右邊與左上角的值，並且左邊，上邊，左上邊總是相等的。這些奧祕需要更嚴格的數學知識來論證。

假設有兩個陣列，A和B。A[i]為A的第i個元素，A(i)為由A的第一個元素到第i個元素所組成的字首。m(i, j)為A(i)和B(j)的最長公共子序列長度。

由於演算法本身的遞推性質，其實只要證明，對於某個i和j：

  m(i, j) = m(i-1, j-1) + 1 （當A[i] = B[j]時）

  m(i, j) = max( m(i-1, j), m(i, j-1) ) （當A[i] != B[j]時）

第一個式子很好證明，即當A[i] = B[j]時。可以用反證，假設m(i, j) > m(i-1, j-1) + 1 （m(i, j)不可能小於m(i-1, j-1) + 1，原因很明顯），那麼可以推出m(i-1, j-1)不是最長的這一矛盾結果。

第二個有些trick。當A[i] != B[j]時，還是反證，假設m(i, j) > max( m(i-1, j), m(i, j-1) )。

由反證假設，可得m(i, j) > m(i-1, j)。這個可以推出A[i]一定在m(i, j)對應的LCS序列中（反證可得）。而由於A[i] != B[j]，故B[j]一定不在m(i, j)對應的LCS序列中。所以可推出m(i, j) = m(i, j-1)。這就推出了與反正假設矛盾的結果。

得證。

假設有兩個陣列，A和B。A[i]為A的第i個元素，A(i)為由A的第一個元素到第i個元素所組成的字首。m(i, j)為A(i)和B(j)的最長公共子序列長度。

由於演算法本身的遞推性質，其實只要證明，對於某個i和j：

m(i, j) = m(i-1, j-1) + 1 （當A[i] = B[j]時）

m(i, j) = max( m(i-1, j), m(i, j-1) ) （當A[i] != B[j]時）

第一個式子很好證明，即當A[i] = B[j]時。可以用反證，假設m(i, j) > m(i-1, j-1) + 1 （m(i, j)不可能小於m(i-1, j-1) + 1，原因很明顯），那麼可以推出m(i-1, j-1)不是最長的這一矛盾結果。

第二個有些trick。當A[i] != B[j]時，還是反證，假設m(i, j) > max( m(i-1, j), m(i, j-1) )。

由反證假設，可得m(i, j) > m(i-1, j)。這個可以推出A[i]一定在m(i, j)對應的LCS序列中（反證可得）。而由於A[i] != B[j]，故B[j]一定不在m(i, j)對應的LCS序列中。所以可推出m(i, j) = m(i, j-1)。這就推出了與反正假設矛盾的結果。

得證。

我們現在用下面的方程來繼續填表了。

程式實現

//by 司徒正美
function LCS(str1, str2){
        var rows =  str1.split("")
        rows.unshift("")
        var cols =  str2.split("")
        cols.unshift("")
        var m = rows.length 
        var n = cols.length 
        var dp = []
        for(var i = 0; i < m; i++){ 
            dp[i] = []
            for(var j = 0; j < n; j++){ 
                if(i === 0 || j === 0){
                    dp[i][j] = 0
                    continue
                }
              
                if(rows[i] === cols[j]){ 
                    dp[i][j] = dp[i-1][j-1] + 1 //對角＋1
                }else{
                    dp[i][j] = Math.max( dp[i-1][j], dp[i][j-1]) //對左邊，上邊取最大
                }
            }
            console.log(dp[i].join(""))//除錯
        } 
        return dp[i-1][j-1]
    }

//by 司徒正美

function LCS(str1, str2){

var rows = str1.split("")

rows.unshift("")

var cols = str2.split("")

cols.unshift("")

var m = rows.length

var n = cols.length

var dp = []

for(var i = 0; i < m; i++){

dp[i] = []

for(var j = 0; j < n; j++){

if(i === 0 || j === 0){

dp[i][j] = 0

continue

}

if(rows[i] === cols[j]){

dp[i][j] = dp[i-1][j-1] + 1 //對角＋1

}else{

dp[i][j] = Math.max( dp[i-1][j], dp[i][j-1]) //對左邊，上邊取最大

}

console.log(dp[i].join(""))//除錯

}

return dp[i-1][j-1]

}

LCS可以進一步簡化，只要通過挪位置，省去新陣列的生成

//by司徒正美
function LCS(str1, str2){
    var m = str1.length 
    var n = str2.length
    var dp = [new Array(n+1).fill(0)] //第一行全是0
    for(var i = 1; i <= m; i++){ //一共有m+1行
        dp[i] = [0] //第一列全是0
        for(var j = 1; j <= n; j++){//一共有n+1列
            if(str1[i-1] === str2[j-1]){ 
                //注意這裡，str1的第一個字元是在第二列中，因此要減1，str2同理
                dp[i][j] = dp[i-1][j-1] + 1 //對角＋1
            } else {
                 dp[i][j] = Math.max( dp[i-1][j], dp[i][j-1]) 
            }
        }
    } 
    return dp[m][n];
}

//by司徒正美

function LCS(str1, str2){

var m = str1.length

var n = str2.length

var dp = [new Array(n+1).fill(0)] //第一行全是0

for(var i = 1; i <= m; i++){ //一共有m+1行

dp[i] = [0] //第一列全是0

for(var j = 1; j <= n; j++){//一共有n+1列

if(str1[i-1] === str2[j-1]){

//注意這裡，str1的第一個字元是在第二列中，因此要減1，str2同理

dp[i][j] = dp[i-1][j-1] + 1 //對角＋1

} else {

dp[i][j] = Math.max( dp[i-1][j], dp[i][j-1])

}

return dp[m][n];

}

列印一個LCS

我們再給出列印函式，先看如何列印一個。我們從右下角開始尋找，一直找到最上一行終止。因此目標字串的構建是倒序。為了避免使用stringBuffer這樣麻煩的中間量，我們可以通過遞迴實現，每次執行程式時，只返回一個字串，沒有則返回一個空字串，以printLCS(x,y,...) + str[i]相加，就可以得到我們要求的字串。

我們再寫出一個方法，來驗證我們得到的字串是否真正的LCS字串。作為一個已經工作的人，不能寫的程式碼像在校生那樣，不做單元測試就放到線上讓別人踩坑。

//by 司徒正美，列印一個LCS
function printLCS(dp, str1, str2, i, j){
    if (i == 0 || j == 0){
        return "";
    }
    if( str1[i-1] == str2[j-1] ){
        return printLCS(dp, str1, str2, i-1, j-1) + str1[i-1];
    }else{
        if (dp[i][j-1] > dp[i-1][j]){
            return printLCS(dp, str1, str2, i, j-1);
        }else{
            return printLCS(dp, str1, str2, i-1, j);
        }
    }
}
//by司徒正美， 將目標字串轉換成正則，驗證是否為之前兩個字串的LCS
function validateLCS(el, str1, str2){
   var re =  new RegExp( el.split("").join(".*") )
   console.log(el, re.test(str1),re.test(str2))
   return re.test(str1) && re.test(str2)
}

//by 司徒正美，列印一個LCS

function printLCS(dp, str1, str2, i, j){

if (i == 0 || j == 0){

return "";

}

if( str1[i-1] == str2[j-1] ){

return printLCS(dp, str1, str2, i-1, j-1) + str1[i-1];

}else{

if (dp[i][j-1] > dp[i-1][j]){

return printLCS(dp, str1, str2, i, j-1);

}else{

return printLCS(dp, str1, str2, i-1, j);

}

//by司徒正美，將目標字串轉換成正則，驗證是否為之前兩個字串的LCS

function validateLCS(el, str1, str2){

var re = new RegExp( el.split("").join(".*") )

console.log(el, re.test(str1),re.test(str2))

return re.test(str1) && re.test(str2)

}

使用：

function LCS(str1, str2){
    var m = str1.length 
    var n = str2.length
    //....略，自行補充
    var s = printLCS(dp, str1, str2, m, n)
    validateLCS(s, str1, str2)
    return dp[m][n]
}
var c1 = LCS( "ABCBDAB","BDCABA");
console.log(c1) //4 BCBA、BCAB、BDAB
var c2 = LCS("13456778" , "357486782" );
console.log(c2) //5 34678 
var c3 = LCS("ACCGGTCGAGTGCGCGGAAGCCGGCCGAA" ,"GTCGTTCGGAATGCCGTTGCTCTGTAAA" );
console.log(c3) //20 GTCGTCGGAAGCCGGCCGAA

function LCS(str1, str2){

var m = str1.length

var n = str2.length

//....略，自行補充

var s = printLCS(dp, str1, str2, m, n)

validateLCS(s, str1, str2)

return dp[m][n]

}

var c1 = LCS( "ABCBDAB","BDCABA");

console.log(c1) //4 BCBA、BCAB、BDAB

var c2 = LCS("13456778" , "357486782" );

console.log(c2) //5 34678

var c3 = LCS("ACCGGTCGAGTGCGCGGAAGCCGGCCGAA" ,"GTCGTTCGGAATGCCGTTGCTCTGTAAA" );

console.log(c3) //20 GTCGTCGGAAGCCGGCCGAA

列印全部LCS

思路與上面差不多，我們注意一下，在LCS方法有一個Math.max取值，這其實是整合了三種情況，因此可以分叉出三個字串。我們的方法將返回一個es6集合物件，方便自動去掉。然後每次都用新的集合合併舊的集合的字任串。

//by 司徒正美 列印所有LCS
function printAllLCS(dp, str1, str2, i, j){
    if (i == 0 || j == 0){
        return new Set([""])
    }else if(str1[i-1] == str2[j-1]){
        var newSet = new Set()
        printAllLCS(dp, str1, str2, i-1, j-1).forEach(function(el){
            newSet.add(el + str1[i-1])
        })
        return newSet
    }else{
        var set = new Set()
        if (dp[i][j-1] >= dp[i-1][j]){
            printAllLCS(dp, str1, str2, i, j-1).forEach(function(el){
              set.add(el)
            })
        }
        if (dp[i-1][j] >= dp[i][j-1]){//必須用>=，不能簡單一個else搞定
            printAllLCS(dp, str1, str2, i-1, j).forEach(function(el){
              set.add(el)
            })
        }   
        return set
    } 
 }

//by 司徒正美列印所有LCS

function printAllLCS(dp, str1, str2, i, j){

if (i == 0 || j == 0){

return new Set([""])

}else if(str1[i-1] == str2[j-1]){

var newSet = new Set()

printAllLCS(dp, str1, str2, i-1, j-1).forEach(function(el){

newSet.add(el + str1[i-1])

})

return newSet

}else{

var set = new Set()

if (dp[i][j-1] >= dp[i-1][j]){

printAllLCS(dp, str1, str2, i, j-1).forEach(function(el){

set.add(el)

})

}

if (dp[i-1][j] >= dp[i][j-1]){//必須用>=，不能簡單一個else搞定

printAllLCS(dp, str1, str2, i-1, j).forEach(function(el){

set.add(el)

})

}

return set

}

使用：

function LCS(str1, str2){
    var m = str1.length 
    var n = str2.length
    //....略，自行補充
    var s =  printAllLCS(dp, str1, str2, m, n)
    console.log(s)
    s.forEach(function(el){
        validateLCS(el,str1, str2)
        console.log("輸出LCS",el)
    })
    return dp[m][n]
}
var c1 = LCS( "ABCBDAB","BDCABA");
console.log(c1) //4 BCBA、BCAB、BDAB
var c2 = LCS("13456778" , "357486782" );
console.log(c2) //5 34678 
var c3 = LCS("ACCGGTCGAGTGCGCGGAAGCCGGCCGAA" ,"GTCGTTCGGAATGCCGTTGCTCTGTAAA" );
console.log(c3) //20 GTCGTCGGAAGCCGGCCGAA

function LCS(str1, str2){

var m = str1.length

var n = str2.length

//....略，自行補充

var s = printAllLCS(dp, str1, str2, m, n)

console.log(s)

s.forEach(function(el){

validateLCS(el,str1, str2)

console.log("輸出LCS",el)

})

return dp[m][n]

}

var c1 = LCS( "ABCBDAB","BDCABA");

console.log(c1) //4 BCBA、BCAB、BDAB

var c2 = LCS("13456778" , "357486782" );

console.log(c2) //5 34678

var c3 = LCS("ACCGGTCGAGTGCGCGGAAGCCGGCCGAA" ,"GTCGTTCGGAATGCCGTTGCTCTGTAAA" );

console.log(c3) //20 GTCGTCGGAAGCCGGCCGAA

空間優化

使用滾動陣列：

function LCS(str1, str2){
    var m = str1.length 
    var n = str2.length
    var dp = [new Array(n+1).fill(0)],now = 1，row //第一行全是0
    for(var i = 1; i <= m; i++){ //一共有2行
        row = dp[now] = [0] //第一列全是0
        for(var j = 1; j <= n; j++){//一共有n+1列
            if(str1[i-1] === str2[j-1]){ 
                //注意這裡，str1的第一個字元是在第二列中，因此要減1，str2同理
                dp[now][j] = dp[i-now][j-1] + 1 //對角＋1
            } else {
                dp[now][j] = Math.max( dp[i-now][j], dp[now][j-1]) 
            }
        }
        now = 1- now; //1-1=>0;1-0=>1; 1-1=>0 ...
    } 
    return row ? row[n]: 0
}

function LCS(str1, str2){

var m = str1.length

var n = str2.length

var dp = [new Array(n+1).fill(0)],now = 1，row //第一行全是0

for(var i = 1; i <= m; i++){ //一共有2行

row = dp[now] = [0] //第一列全是0

for(var j = 1; j <= n; j++){//一共有n+1列

if(str1[i-1] === str2[j-1]){

//注意這裡，str1的第一個字元是在第二列中，因此要減1，str2同理

dp[now][j] = dp[i-now][j-1] + 1 //對角＋1

} else {

dp[now][j] = Math.max( dp[i-now][j], dp[now][j-1])

}

now = 1- now; //1-1=>0;1-0=>1; 1-1=>0 ...

}

return row ? row[n]: 0

}

危險的遞迴解法

str1的一個子序列相應於下標序列{1, 2, …, m}的一個子序列，因此，str1共有${2^m}$個不同子序列（str2亦如此，如為${2^n}$），因此複雜度達到驚人的指數時間（${2^m * 2^n}$）。

//警告，字串的長度一大就會爆棧
function LCS(str1, str2, a, b) {
      if(a === void 0){
          a = str1.length - 1
      }
      if(b === void 0){
          b = str2.length - 1
      }
      if(a == -1 || b == -1){
          return 0
      } 
      if(str1[a] == str2[b]) {
         return LCS(str1, str2,  a-1, b-1)+1;
      }
      if(str1[a] != str2[b]) {
         var x =  LCS(str1, str2, a, b-1)
         var y =  LCS(str1, str2, a-1, b)
         return x >= y ? x : y
      }
  }

//警告，字串的長度一大就會爆棧

function LCS(str1, str2, a, b) {

if(a === void 0){

a = str1.length - 1

}

if(b === void 0){

b = str2.length - 1

}

if(a == -1 || b == -1){

return 0

}

if(str1[a] == str2[b]) {

return LCS(str1, str2, a-1, b-1)+1;

}

if(str1[a] != str2[b]) {

var x = LCS(str1, str2, a, b-1)

var y = LCS(str1, str2, a-1, b)

return x >= y ? x : y

}

參考連結

動態規劃(最長公共子序列LCS)
2020-11-17
動態規劃
lCS(最長公共子串)
2024-04-15
演算法題：最長公共子序列
2015-05-21
演算法
最長公共子序列（JAVA）
2018-10-15
Java
java 實現最長公共子序列
2020-11-01
Java
最長公共子序列求方案數
2024-03-20
[譯] Swift 演算法學院 - 最長公共子序列演算法
2018-04-23
Swift演算法
[演算法筆記]動態規劃之最長公共子串和最長公共子序列
2018-02-07
演算法筆記動態規劃
牛客網 Coincidence（最長公共子串LCS板題）
2019-01-28
IDE
動態規劃-最長公共子序列
2018-06-24
動態規劃
動態規劃——最長公共子序列
2018-06-06
動態規劃
力扣1143. 最長公共子序列動態規劃之最長公共子序列
2020-10-03
力扣動態規劃
經典演算法題每日演練——最長公共子序列
2021-09-09
演算法
詳解動態規劃最長公共子序列--JavaScript實現
2018-05-28
動態規劃JavaScript
最長公共子序列的程式碼實現
2017-02-13
【LeetCode動態規劃#14】子序列系列題（最長遞增子序列、最長連續遞增序列、最長重複子陣列、最長公共子序列）
2023-04-27
LeetCode動態規劃陣列
最長公共子序列，遞迴簡單程式碼
2017-03-08
遞迴
最長公共子序列問題—動態規劃sdut
2020-12-07
動態規劃
LeetCode 1143.最長公共子序列
2020-12-08
LeetCode
[題解]P1439 【模板】最長公共子序列
2024-03-30
以最長公共子序列問題理解動態規劃演算法（DP）
2020-12-29
動態規劃演算法
“最長公共字串子序列”問題的動態規劃法演算法
2008-01-03
字串動態規劃演算法
領釦LintCode演算法問題答案-77. 最長公共子序列
2020-10-17
演算法
字串篇(python)—兩個字串的最長公共子序列
2020-12-06
字串Python
動態規劃經典問題----最長公共子序列
2018-06-02
動態規劃
[Java] 藍橋杯ADV-202 演算法提高最長公共子序列
2018-10-10
Java演算法
最長公共子序列與最小編輯距離-你有更快的演算法麼？
2017-12-20
演算法
最長公共子序列&迴文字串 nyoj動態規劃
2017-03-21
字串動態規劃
演算法：最長公共字首
2019-02-25
演算法
最長上升子序列（LIS）的兩種演算法
2014-08-13
演算法
動態規劃之最長公共子序列求解
2019-02-21
動態規劃
微軟演算法面試題：如何找最長的增長子序列
2018-03-20
微軟演算法面試題
兩個字串的最長公共子串
2012-11-04
字串
演算法之字串——最長公共字首
2020-09-29
演算法字串
淺談最長公共子序列引發的經典動態規劃問題
2022-04-07
動態規劃
動態規劃：最長上升子序列
2021-08-08
動態規劃
最長上升子序列動態規劃
2020-12-25
動態規劃
最長等差數列；及子序列分析
2013-09-16

LCS 演算法：Javascript 最長公共子序列

基本概念

問題分析

程式實現

列印一個LCS

列印全部LCS

空間優化

危險的遞迴解法

參考連結

相關文章