动态规划算法典型应用之最长公共子序列LCS问题_最长公共子序列问题有哪些方面的应用

动态规划算法典型应用之最长公共子序列LCS问题

• 继续学习动态规划233。之前有了投资问题和背包问题的基础，LCS问题比较好理解了。先来看看LCS的定义。

• 算了，也不整定义了，不太好理解，直接上例子。

• 有一个X序列 X=<A,B,C,B,D,A,B> 还有一个Y序列 Y=<B,D,C,A,B,A> 我们可以找到一些最长子序列，比如 B C B A 或者 B C A B。我们可以看到这个所谓的子序列不一定是在原序列里连续，而是可以间断着进行选择。而最长公共子序列也不一定只有一个，而是可能有多个，只要它们的长度都是最长的，我们把它们都称之为最长公共子序列Longest Common Subsequence

• 好了，如果我们用蛮力算法，X有多少子序列呢？就像之前说的，子序列在原序列中是可以间断的，所以所有子序列的个数就是$2^7$个，为什么呢，很容易理解，每一个元素有选择和不选择两种可能，所有的元素都进行这种可能性选择，会得到一个个子序列。然后我们把送X序列中蛮力枚举出来的子序列到Y中进行判断是否存在。所以最后的时间复杂度是$O(2^{m}n)$ （m表示X的元素个数，n表示Y的元素个数）。指数的时间复杂度显然是不行的，我们需要使用使用动态规划算法。

• 动态规划算法的重要步骤是如何界定子问题的边界，成功界定后，题目就会迎刃而解了。在这个问题中，我们能发现的两个参数就是X的长度和Y的长度，所以我们很容易联想到把这两个参数看成问题的规模。设优化函数C[i,j]表示Xi与Yj的最长公共子序列的长度。Xi表示X的前i个元素，Yj表示Y的前j个元素。我们只要用两层循环，第一层循环遍历X的规模，第二层循环遍历Y的规模，在计算当前规模C[i,j]时，充分利用之前计算出来的值，最后的时间复杂度就是两层循环$O(mn)$，十分牛皮。

• 递推方程

C [ i , j ] = { C [ i − 1 , j − 1 ] + 1 x i = y j m a x { C [ i , j − 1 ] , C [ i − 1 , j } x i ≠ y j C[i,j]=

$$\begin{cases} C[i-1,j-1]+1& {x_i=y_j}\\ max\{C[i,j-1],C[i-1,j\}& x_i \neq y_j\end{cases}$$ C[i,j]={C[i−1,j−1]+1max{C[i,j−1],C[i−1,j}​xi​=yj​xi​​=yj​​

• 同时$C[0,j]=C[i,0]=0$作为初值

• 来解释一下递归方程吧，第一个$x_i=y_j$的情况，也就是又遇到了X和Y相同元素的时候，这时候我们的最长子序列长度可以在之前的基础上加1了，之前的基础是什么呢？是规模为$i-1$和$j-1$的子问题。

• 那么第二个情况，$x_i\ne y_j$，不相等那怎么办呢？我们就要看规模为$i-1$和$j$ 与规模为$i$ 和 $j-1$这两个子问题的最长子序列长度大小了，选择大的那个。

• 我们现在来模拟求ABC和ABD的最长子序列的过程。

  i = 1
  	j = 1
  		X[1] == Y[1]
  			C[1,1] = C[0,0] + 1 = 1;
  	j = 2
  		X[1] != Y[2]
          	C[1,2] = C[0,2] = 0;
      j = 3
      	x[1] != Y[3]
      		C[1,3] = C[0,3] = 0;
  i = 2
  	j = 1
  		X[2] != Y[1]
  			C[2,1] = C[1,1] = 1;
  	j = 2
  		X[2] == Y[2]
  			C[2,2] = C[1,1] + 1 = 2;
  	j = 3
  		X[2] != Y[3]
  			C[2,3] = C[2,2] = 2;
  i = 3
  	j = 1
  		X[3] != Y[1]
  			C[3,1] = C[2,1] = 1;
  	j = 2
  		X[3] != Y[2]
  			C[3,2] = C[2,2] = 2;
  	j = 3
  		X[3] != Y[3]
  			C[3,3] = C[2,3] = 2;
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30

  i\j	1	2	3
  1	1	0	0
  2	1	2	2
  3	1	2	2

• 最终的结果就是C[3,3] = 2;

• 以下是我根据书上的数据写的代码

  //LCS也就是Longest Common Subsequence，公共最长子序列
  //输入，字符数组X[8]和字符数组Y[7]
  //输出，最长公共子序列得长度，并给出一个最长公共子序列
  #include <iostream>
  #include <cstring>
  using namespace std;
  
  int main()
  {
      char X[8] = {' ', 'A', 'B', 'C', 'B', 'D', 'A', 'B'};
      char Y[7] = {' ', 'B', 'D', 'C', 'A', 'B', 'A'};
      int C[8][7] = {0};    //优化函数C[i][j]，表示当Xi与Yj的最长公共子序列的长度
      char B[8][7] = {' '}; //记录追踪过程
      for (int i = 1; i <= 7; i++)
      {
          for (int j = 1; j <= 6; j++)
          {
              if (X[i] == Y[j])
              {
                  C[i][j] = C[i - 1][j - 1] + 1;
                  B[i][j] = 'S'; //S代表Slash,↖
              }
              else
              {
                  if (C[i - 1][j] >= C[i][j - 1]) //上边的大
                  {
                      C[i][j] = C[i - 1][j];
                      B[i][j] = 'U'; //U代表up, ↑
                  }
                  else
                  {
                      C[i][j] = C[i][j - 1];
                      B[i][j] = 'L'; //L代表left,←
                  }
              }
          }
      }
      cout << "LCS's length: " << C[7][6] << endl;
      int i = 7, j = 6;
      string LCS = "";
      while (i != 0 && j != 0)
      {
          if (B[i][j] == 'S')
          {
              LCS = X[i] + LCS;
              i--;
              j--;
          }
          else if (B[i][j] == 'U')
              i--;
          else
              j--;
      }
      cout << "one of LCS: " << LCS << endl;
      return 0;
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56

• 以下为运行结果

  

• 好好学习，天天向上！！