《算法导论》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)

 1  2 m ← length[X]
 3 n ← length[Y]
 4 for i ← 1 to m
 5       do c[i, 0] ← 0
 6 for j ← 0 to n
 7     do c[0, j] ← 0
 8 for i ← 1 to m
 9     do for j ← 1 to n
10             do if xi = yj
11                    then c[i, j] ← c[i - 1, j - 1] + 1
12                         b[i, j] ← "↖"
13                    else if c[i - 1, j] ≥ c[i, j - 1]
14                           then c[i, j] ← c[i - 1, j]
15                                b[i, j] ← "↑"
16                           else c[i, j] ← c[i, j - 1]
17                                b[i, j] ← ←
18 return c and b

C++实现：

  1 #include <iostream>
  2 #include <stdio.h>
  3 #include <string.h>
  4 
  5 using namespace std;
  6 
  7 enum
  8 dir {dInit = 0, dLeft, dUp, dUpLeft};//定义方向初始化值dInit，三个方向左dLeft、上dUp、左上dUpLeft
  9 
 10 void LCSPrint(int **LCS_direction, const char* la, const char* lb, int row, int col)
 11 {
 12     if (la == NULL || lb == NULL)
 13         return;
 14 
 15     int lengthA = strlen(la);
 16     int lengthB = strlen(lb);
 17 
 18     if (lengthA ==0 || lengthB == 0 || !(row < lengthA && col < lengthB))
 19         return;
 20 
 21     if (LCS_direction[row][col] == dUpLeft)
 22     {
 23         if (row > 0 && col > 0)
 24             LCSPrint(LCS_direction, la, lb, row - 1, col - 1);
 25 
 26         printf("%c", la[row]);
 27     }
 28     else if (LCS_direction[row][col] == dUp)
 29     {
 30         if (row > 0)
 31             LCSPrint(LCS_direction, la, lb, row - 1, col);
 32     }
 33     else if(LCS_direction[row][col] == dLeft)
 34     {
 35         if (col > 0)
 36             LCSPrint(LCS_direction, la, lb, row, col - 1);
 37     }
 38 }
 39 
 40 int
 41 LCSLength(const char *la, const char *lb)
 42 {
 43     if (!la || !lb)
 44         return 0;
 45 
 46     int lengthA = strlen(la);
 47     int lengthB = strlen(lb);
 48 
 49     if (!lengthA || !lengthB)
 50         return 0;
 51 
 52     int i, j;
 53 
 54     //创建并初始化存放长度的二维数组
 55     int **LCS_length;
 56     LCS_length = (int**)(new int[lengthA]);
 57     for (i = 0; i < lengthA; ++i)
 58         LCS_length[i] = (int*)new int[lengthB];
 59 
 60     for (i = 0; i < lengthA; ++i)
 61         for (j = 0; j < lengthB; ++j)
 62             LCS_length[i][j] = 0;
 63 
 64     //创建并初始化存放方向的二维数组，方向在枚举enum dir中定义
 65     int **LCS_direction;
 66     LCS_direction = (int**)(new int[lengthA]);
 67     for (i = 0; i < lengthA; ++i)
 68         LCS_direction[i] = (int*)new int[lengthB];
 69 
 70     for (i = 0; i < lengthA; ++i)
 71         for (j = 0; j < lengthB; ++j)
 72             LCS_direction[i][j] = dInit;
 73 
 74     for (i = 0; i < lengthA; ++i)
 75     {
 76         for (j = 0; j < lengthB; ++j)
 77         {
 78             if (i == 0 || j == 0)
 79             {
 80                 if (la[i] == lb[j])
 81                 {
 82                     LCS_length[i][j] = 1;
 83                     LCS_direction[i][j] = dUpLeft;
 84                 }
 85                 else
 86                 {
 87                     if (i > 0)
 88                     {
 89                         //i > 0不是第一行
 90                         LCS_length[i][j] = LCS_length[i - 1][j];
 91                         LCS_direction[i][j] = dUp;
 92                     }
 93                     if (j > 0)
 94                     {
 95                         //j > 0不是第一列
 96                         LCS_length[i][j] = LCS_length[i][j - 1];
 97                         LCS_direction[i][j] = dLeft;
 98                     }
 99                 }
100             }
101 
102             else if (la[i] == lb[j])
103             {
104                 LCS_length[i][j] = LCS_length[i - 1][j - 1] + 1;
105                 LCS_direction[i][j] = dUpLeft;
106             }
107 
108             else if (LCS_length[i - 1][j] > LCS_length[i][j - 1])
109             {
110                 LCS_length[i][j] = LCS_length[i - 1][j];
111                 LCS_direction[i][j] = dUp;
112             }
113 
114             else
115             {
116                 LCS_length[i][j] = LCS_length[i][j - 1];
117                 LCS_direction[i][j] = dLeft;
118             }
119         }
120     }
121     LCSPrint(LCS_direction, la, lb, lengthA - 1, lengthB - 1);
122     cout << endl;
123     return LCS_length[lengthA - 1][lengthB - 1];
124 }
125 
126 int main()
127 {
128     const char* la = "ABCBDAB";
129     const char* lb = "BDCABA";
130     int length = LCSLength(la, lb);
131     cout << "最长子序列长度为：" << length << endl;
132     return 0;
133 }

Python实现：

 1 def LCS(la, lb):
 2     if la == "" or lb == "":
 3         return
 4     lengthA = len(la)
 5     lengthB = len(lb)
 6     lcs = [[0] for i in range(0, lengthA + 1)]
 7     lcs[0] = [0 for j in range(0, lengthB + 1)]
 8     for i in range(lengthA):
 9         for j in range(lengthB):
10             lcs[i + 1].append(lcs[i][j] + 1 if la[i] == lb[j] else max(lcs[i][j + 1], lcs[i + 1][j]))
11     i = lengthA - 1
12     j = lengthB - 1
13     lcsstr = ""
14     while True:
15         if i == -1 or j == -1:
16             break
17         if la[i] == lb[j]:
18             lcsstr = "%s%s" % (la[i], lcsstr)
19             i = i - 1
20             j = j - 1
21         else:
22             if lcs[i][j + 1] > lcs[i + 1][j]:
23                 i = i - 1
24             else:
25                 j = j - 1
26     print lcsstr
27     
28 LCS("ABCBDAB", "BDCABA")

 

 

 

标签: Python, 编程, 算法导论, C/C++, 代码实现, 算法, CLRS, 最长公共子序列, LCS