《算法導論》CLRS算法C++實現（十二）P208 最長公共子序列LCS

 

 

給定兩個序列X和Y，如果Z既是X的一個子序列又是Y的一個子序列，則稱序列Z是X和Y的一個公共子序列。

 

在最長公共子序列問題（LCS）中，給定了兩個序列X=<x₁，x₂，…，x_m>和Y=<y₁，y₂，…，y_n>，希望找出X和Y的最大長度的公共子序列。最直觀且容易想到的方法是枚舉出X的所有子序列，然后逐一檢查看其是否為Y的子序列，並隨時記錄所發現的最長子序列。這種方法的時間復雜度是指數級的，對於較長的序列來說是不實際的。

 

LCS問題的最優子結構：

 

若x_m=y_n，則z_k=x_m=yn且Z_k-1是X_m-1和Y_n-1的最長公共子序列；
若x_m≠y_n且z_k≠x_m ，則Z是X_m-1和Y的最長公共子序列；
若x_m≠y_n且z_k≠y_n ，則Z是X和Y_n-1的最長公共子序列。

算法：LCS-LENGTH(X, Y)

 2 m ← length[X]
n ← length[Y]
for i ← 1 to m
      do c[i, 0] ← 0
for j ← 0 to n
    do c[0, j] ← 0
for i ← 1 to m
    do for j ← 1 to n
            do if xi = yj
                   then c[i, j] ← c[i - 1, j - 1] + 1
                        b[i, j] ← "↖"
                   else if c[i - 1, j] ≥ c[i, j - 1]
                          then c[i, j] ← c[i - 1, j]
                               b[i, j] ← "↑"
                          else c[i, j] ← c[i, j - 1]
                               b[i, j] ← ←
return c and b

C++實現：

#include <iostream>
#include <stdio.h>
#include <string.h>

using namespace std;

enum
dir {dInit = 0, dLeft, dUp, dUpLeft};//定義方向初始化值dInit，三個方向左dLeft、上dUp、左上dUpLeft

void LCSPrint(int **LCS_direction, const char* la, const char* lb, int row, int col)
{
    if (la == NULL || lb == NULL)
        return;

    int lengthA = strlen(la);
    int lengthB = strlen(lb);

    if (lengthA ==0 || lengthB == 0 || !(row < lengthA && col < lengthB))
        return;

    if (LCS_direction[row][col] == dUpLeft)
    {
        if (row > 0 && col > 0)
            LCSPrint(LCS_direction, la, lb, row - 1, col - 1);

        printf("%c", la[row]);
    }
    else if (LCS_direction[row][col] == dUp)
    {
        if (row > 0)
            LCSPrint(LCS_direction, la, lb, row - 1, col);
    }
    else if(LCS_direction[row][col] == dLeft)
    {
        if (col > 0)
            LCSPrint(LCS_direction, la, lb, row, col - 1);
    }
}

int
LCSLength(const char *la, const char *lb)
{
    if (!la || !lb)
        return 0;

    int lengthA = strlen(la);
    int lengthB = strlen(lb);

    if (!lengthA || !lengthB)
        return 0;

    int i, j;

    //創建並初始化存放長度的二維數組
    int **LCS_length;
    LCS_length = (int**)(new int[lengthA]);
    for (i = 0; i < lengthA; ++i)
        LCS_length[i] = (int*)new int[lengthB];

    for (i = 0; i < lengthA; ++i)
        for (j = 0; j < lengthB; ++j)
            LCS_length[i][j] = 0;

    //創建並初始化存放方向的二維數組，方向在枚舉enum dir中定義
    int **LCS_direction;
    LCS_direction = (int**)(new int[lengthA]);
    for (i = 0; i < lengthA; ++i)
        LCS_direction[i] = (int*)new int[lengthB];

    for (i = 0; i < lengthA; ++i)
        for (j = 0; j < lengthB; ++j)
            LCS_direction[i][j] = dInit;

    for (i = 0; i < lengthA; ++i)
    {
        for (j = 0; j < lengthB; ++j)
        {
            if (i == 0 || j == 0)
            {
                if (la[i] == lb[j])
                {
                    LCS_length[i][j] = 1;
                    LCS_direction[i][j] = dUpLeft;
                }
                else
                {
                    if (i > 0)
                    {
                        //i > 0不是第一行
                        LCS_length[i][j] = LCS_length[i - 1][j];
                        LCS_direction[i][j] = dUp;
                    }
                    if (j > 0)
                    {
                        //j > 0不是第一列
                        LCS_length[i][j] = LCS_length[i][j - 1];
                        LCS_direction[i][j] = dLeft;
                    }
                }
            }

            else if (la[i] == lb[j])
            {
                LCS_length[i][j] = LCS_length[i - 1][j - 1] + 1;
                LCS_direction[i][j] = dUpLeft;
            }

            else if (LCS_length[i - 1][j] > LCS_length[i][j - 1])
            {
                LCS_length[i][j] = LCS_length[i - 1][j];
                LCS_direction[i][j] = dUp;
            }

            else
            {
                LCS_length[i][j] = LCS_length[i][j - 1];
                LCS_direction[i][j] = dLeft;
            }
        }
    }
    LCSPrint(LCS_direction, la, lb, lengthA - 1, lengthB - 1);
    cout << endl;
    return LCS_length[lengthA - 1][lengthB - 1];
}

int main()
{
    const char* la = "ABCBDAB";
    const char* lb = "BDCABA";
    int length = LCSLength(la, lb);
    cout << "最長子序列長度為：" << length << endl;
    return 0;
}

Python實現：

def LCS(la, lb):
    if la == "" or lb == "":
        return
    lengthA = len(la)
    lengthB = len(lb)
    lcs = [[0] for i in range(0, lengthA + 1)]
    lcs[0] = [0 for j in range(0, lengthB + 1)]
    for i in range(lengthA):
        for j in range(lengthB):
            lcs[i + 1].append(lcs[i][j] + 1 if la[i] == lb[j] else max(lcs[i][j + 1], lcs[i + 1][j]))
    i = lengthA - 1
    j = lengthB - 1
    lcsstr = ""
    while True:
        if i == -1 or j == -1:
            break
        if la[i] == lb[j]:
            lcsstr = "%s%s" % (la[i], lcsstr)
            i = i - 1
            j = j - 1
        else:
            if lcs[i][j + 1] > lcs[i + 1][j]:
                i = i - 1
            else:
                j = j - 1
    print lcsstr
    
LCS("ABCBDAB", "BDCABA")