动态规划学习与实例(2) 最长公共子序列

最长公共子序列LCS

( longest common subsequence )

问题描述

1. 一个给定序列的子序列是该给定序列中去掉0个或者多个元素，此处的子序列不要求必须连续.
2. 给定序列 $X$ 和 $Y$ , 如果 $Z$ 既是 $X$ 的一个子序列,又是 $Y$ 的一个子序列， 则 $Z$ 是 $X$ 和 $Y$ 的公共子序列.
3. 找出给定序列 $X$ 和 $Y$ 的最长公共子序列 $LCS$.

问题分析

1. 穷举方法：强力枚举出$X$ 的所有子序列，然后逐一检查是否为 $Y$ 的子序列. 假设 $X$ 有$m$个元素，其子序列有 $2^m$ 个，需要指数时间.
2. 动态规划法：$LCS$ 问题具有最优子结构，可以将指数时间化为多项式时间.

$LCS$ 动态规划最优子结构

1. 假设$Z_k=<z_1, z_2, ... , z_k>$为$X_m$和$Y_n$的任意$LCS$,序列$X_m=<x_1, x_2, ... , x_m>,Y_n=<y_1, y_2, ... , y_n>$.
2. 如果$x_m = y_n$, 那么$z_k=x_m=y_n$,且$Z_{k-1}$是$X_{m-1}$和$Y_{n-1}$的一个$LCS$.
3. 如果$x_m \neq y_n$, 则$z_k\neq x_m$, $Z_k$是$X_{m-1}$和$Y_n$的一个$LCS$.
4. 如果$x_m\neq y_n$, 则$z_k\neq y_n$, $Z_k$是$X_m$和$Y_{n-1}$的一个$LCS$.

$LCS$ 递归关系

定义$c[i,j]$ 为$X_i$和$Y_j$的一个$LCS$的长度.

$$c[i,j]= \begin{cases} 0& \text{$i=0$ or $j=0$}\\ c[i-1,j-1]+1& \text{$i,j>0$ and $x_i=j_i$}\\ max\{c[i,j-1],c[i-1,j]\}& \text{$i,j>0$ and $x_i\neq j_i$} \end{cases}$$

C++代码

#include <iostream>
#include <vector>
#include <string>
using namespace std;
typedef vector< vector<int> > mat2;
class Seqmatching
{
        string seq1;
        string seq2;
    public:
        Seqmatching();
        Seqmatching(string seqc1, string seqc2);
        ~Seqmatching();
        void matching(mat2 & seq_n, mat2 & tra) const;
        void lcs(const mat2 & tra, string & subseq, int i, int j) const;
};
Seqmatching::Seqmatching()
{
        seq1 = "";
        seq2 = "";
}
Seqmatching::Seqmatching(string seqc1, string seqc2)
{
        seq1 = seqc1;
        seq2 = seqc2;
}
Seqmatching::~Seqmatching()
{
}
void Seqmatching::matching(mat2 & seq_n, mat2 & tra) const
{
        int n1 = seq1.length();
        int n2 = seq2.length();
        for (int i=1; i<=n1; ++i)
        {
                for (int j=1; j<=n2; ++j)
                {
                        if (seq1.at(i-1) == seq2.at(j-1))
                        {
                                seq_n.at(i).at(j) = seq_n.at(i-1).at(j-1) + 1;
                                tra.at(i).at(j) = 3;    
                        }
                        else
                        {
                                if (seq_n.at(i-1).at(j) >= seq_n.at(i).at(j-1))
                                {
                                        seq_n.at(i).at(j) = seq_n.at(i-1).at(j);
                                        tra.at(i).at(j) = 2;
                                }
                                else
                                {
                                        seq_n.at(i).at(j) = seq_n.at(i).at(j-1);
                                        tra.at(i).at(j) = 1;
                                }
                        }
                }
        }
}
void Seqmatching::lcs(const mat2 & tra, string & subseq, int i, int j) const
{
        subseq.clear();
        if (i!=0 && j!=0)
        {
                if (tra.at(i).at(j) == 3)
                {
                        lcs(tra, subseq, i-1, j-1);
                        subseq += seq1.substr(i-1, 1);
                }
                else
                {
                        if(tra.at(i).at(j) == 2)
                        {
                                lcs(tra, subseq, i-1, j);
                        }
                        else
                        {
                                lcs(tra, subseq, i, j-1);
                        }
                }
        }
}
int main(int argc, char** argv)
{       string seq1(argv[1]);
        string seq2(argv[2]);
        Seqmatching seqm(seq1,seq2);
        int n1 = seq1.length();
        int n2 = seq2.length();
        mat2 seq_n(n1+1, vector<int>(n2+1));
        mat2 tra(n1+1, vector<int>(n2+1));
        seqm.matching(seq_n, tra);
        string subseq;
        seqm.lcs(tra, subseq, n1, n2);          
        cout<<seq1<<endl;
        cout<<seq2<<endl;
        cout<<seq_n.at(n1).at(n2)<<endl;
        cout<<subseq<<endl;
        return 0;
}

分析总结

1. $seq\_n[i,j]$存储最优子问题的解，$tra[i,j]$追溯最优解的位置，$LCS$ 最终保存在subseq字符串中.
2. 该算法的时间复杂度为$O(mn)$. 其中计算最优子问题的时间为$O(mn)$,后续追踪子序列为$O(m+n)$.