最长公共子序列

最长公共子序列算法

---

前言

最优公共子序列

---

一、两个字符串的最长公共子串与最长公共子序列的区别：

最长公共子串要求在原字符串中是连续的，而子序列只需要保持相对顺序一致，并不要求连续。

二、最优子结构分析

设A_i=a₁a₂……a_i , B_j=b₁b₂……b_j , C_k=c₁c₂……c_k
若 C_k 为 A_i 和 B_j 的最长公共子序列，如下

1. 若a_i=B_j , 则 C_k= a_i = b_j ，则 C_k-1= A_i = B_j 的最长公共子序列
2. 若a_i≠b_j , 则 C_k≠ a_i ，则 C_k为A_i-1 和 B_j 的最长公共子序列
3. 若a_i≠b_j , 则 C_k≠ b_j ，则 C_k为 A_i 和 B_j-1 的最长公共子序列

三、递归关系分析

$$L[i,j]=\{\begin{array}{r}0,i=0或j=0\\ L[i-1,j-1]+1,i>0,j>0且ai=bj\\ maxL[i,j-1],L[i-1,j],i>0,j>0且ai\ne bj\end{array}$$
直接利用递归式写出一个计算c[i][j]的递归算法。

由于在所考虑的子问题空间中，总共有θ(mn)个不同的子问题，因此，用动态规划算法自底向上地计算最优值能提高算法的效率
算法如下：

Algorithm lcsLength(x,y,b)
1: mx.length-1;
2: ny.length-1;
3: c[i][0]=0; c[0][i]=0;
4: for (int i = 1; i <= m; i++)
5:    for (int j = 1; j <= n; j++) 
6:       if (x[i]==y[j]) 
7:           c[i][j]=c[i-1][j-1]+1;
8:           b[i][j]=1;
9:        else if (c[i-1][j]>=c[i][j-1]) 
10:          c[i][j]=c[i-1][j];
11:          b[i][j]=2;
12:      else 
13:           c[i][j]=c[i][j-1];
14:           b[i][j]=3;

构造最长公共子序列
Algorithm lcs(int i,int j,char [] x,int [][] b)
   {
      if (i ==0 || j==0) return;
      if (b[i][j]== 1){
        lcs(i-1,j-1,x,b);
        System.out.print(x[i]);
        }
      else if (b[i][j]== 2) lcs(i-1,j,x,b);
        else lcs(i,j-1,x,b);
   }

---

四、总结

1、找出最优解的性质，并刻划其结构特征。.
2、递归地定义最优值。
3、以自底向.上的方式计算出最优值。
4、根据计算最优值时得到的信息，构造最优解。
最优子结构
用动态规划求解优化问题的第一步是描述最优解的结构。如果一个问题的最优解中蕴含了子问题的最优解，即该问题具有最优子结构，这是是用动态规划的前提条件。当然，此时也可能会用贪心策略。
如何寻找问题的最优解与子问题的最优解之间的递推关系（或者叫状态转移方程），是解决动态规划问题最重要的一步。那么如何找到递推关系呢？我们需要考虑两个问题：
1． 有多少个子问题被使用在一个原问题的最优解中？
2． 在决定最优解使用那个子问题时有多少个选择？

完整源代码

1.#include <iostream>
2.#include <cstdio>
3.using namespace std;
4.void lesLength(char* a ,int m ,char* b ,int n , int c[100][100] , int d[100][100]);
5.void sprint(int m , int n , char* a , int d[100][100]);
6.int main()
7.{
8.    char str1[100]= {0};
9.    char str2[100]= {0};
10.    int m = 0 ;
11.    int n = 0 ;
12.    int c[100][100] = { 0 } ;
13.    int d[100][100] = { 0 } ;
14.     cout<<"输入第一个序列："<<endl;
15.    for( int i = 1 ; ; i++ )
16.    {
17.        cin >> str1[i] ;
18.        ++m ;
19.        if (getchar() == '\n')
20.            break ;
21.    }
22.
23.     cout<<"输入第二个序列："<<endl;
24.    for( int i = 1 ; ; i++ )
25.    {
26.        cin >> str2[i] ;
27.        ++n ;
28.        if (getchar() == '\n')
29.            break ;
30.    }
31.    lesLength( str1 , m , str2 , n , c , d) ;
32.    cout << "str1和str2的最长公共子序列： " ;
33.    sprint( m , n , str1 , d) ;
34.    cout << endl ;
35.    cout << "最长公共子序列有  "<<c[m][n] << "个" << endl ;
36.for(int i=0;i<m;i++)
37.{
38.    for(int j=0;j<n;j++)
39.        cout<<c[i][j]<<" ";
40.    cout<<endl;
41.}
42.    return 0;
43.}
44.
45.void lesLength(char* a ,int m ,char* b ,int n , int c[100][100] , int d[100][100])
46.{
47.    for( int i = 0 ; i <= m ; i++)
48.        c[i][0] = 0 ;
49.    for( int j = 0 ; j <= n ; j++)
50.        c[0][j] = 0 ;
51.    for( int i = 1 ; i <= m ; i++)
52.        for( int j = 1 ; j <= n ; j++)
53.    {
54.        if( a[i] == b[j] )
55.        {
56.            c[i][j] = c[i-1][j-1] + 1 ;
57.            d[i][j] = 1 ;
58.        }
59.        else if( c[i-1][j] >= c[i][j-1] )
60.        {
61.            c[i][j] = c[i-1][j] ;
62.            d[i][j] = 2 ;
63.        }
64.        else
65.        {
66.            c[i][j] = c[i][j-1] ;
67.            d[i][j] = 3 ;
68.        }
69.
70.    }
71.}
72.
73.void sprint(int m , int n , char* a , int d[100][100])
74.{
75.    if( m == 0 || n == 0 ) return ;
76.    if( d[m][n] == 1){
77.        sprint( m-1 , n-1 , a , d) ;
78.        cout << a[m] << " " ;
79.
80.    }
81.    else if( d[m][n] == 2)
82.        sprint( m-1 , n , a , d) ;
83.    else
84.        sprint( m , n-1 , a , d) ;
85.}

算法的改进
在算法lcsLength和lcs中，可进一步将数组b省去。事实上，数组元素c[i][j]的值仅由c[i-1][j-1]，c[i-1][j]和c[i][j-1]这3个数组元素的值所确定。对于给定的数组元素c[i][j]，可以不借助于数组b而仅借助于c本身在时间内确定c[i][j]的值是由c[i-1][j-1]，c[i-1][j]和c[i][j-1]中哪一个值所确定的。
如果只需要计算最长公共子序列的长度，则算法的空间需求可大大减少。事实上，在计算c[i][j]时，只用到数组c的第i行和第i-1行。因此，用2行的数组空间就可以计算出最长公共子序列的长度。进一步的分析还可将空间需求减至O(min(m,n))。