1 最长公共子序列问题概述 1.1 问题定义 序列序列如果存在一个序列其中 ，且在中出现的先后顺序要保持一致，则称序列是序列和序列的公共子序列。
要求找出序列和序列的最长的公共子序列。
1.2 举个栗子 序列，序列。
序列的子序列有：
序列的子序列有：
序列和的公共子序列有：
所以序列和的最长公共子序列是：
2 动态规划求解最长公共子序列问题 序列，序列。
假设序列是两个序列的最长公共子序列，则有以下推论：
- 如果，则，且序列是序列和序列的最长公共子序列
- 如果，且，则，序列是序列和序列的最长公共子序列
- 如果，且，则，序列是序列和序列的最长公共子序列 记为序列和序列的最长公共子序列(LCS)的长度。根据上述推论，可以得到的递推公式：
在求最长公共子序列长度矩阵的时候，需要借助一个辅助矩阵来记录求得的过程：
在求得最长公共子序列以及辅助矩阵之后，即可使用回溯法来得到所有的最长公共子序列。
3 实现代码 3.1 LCS.h
# ifndef _LCS_H
# define _LCS_H
# include <vector>
using namespace std;
/**
* 序列类
*/
class Seq{
public:
//数据指针
int* data=nullptr;
//数据长度
int len=0;
Seq(int* data,int len){
this->data=data;
this->len=len;
}
};
// LCS类
class LCS{
private:
//最长公共子序列长度矩阵
int** C=nullptr;
//辅助矩阵
int** src=nullptr;
//使用动态规划方法计算C矩阵和src矩阵
void writeTable(Seq* seq1,Seq* seq2);
//使用回溯方法来得到所有的最长公共子序列
void createSubSeq(Seq* seq1,vector<int>lcs , int i,int j,int MaxLen,vector<vector<int>>&LcsSet);
public:
/**
* 对外的接口
* 输入是两个序列
* 输出是0-n条最长公共子序列
*/
vector<vector<int>> getLCS(Seq* seq1,Seq* seq2);
};
#endif
3.2 LCS.cpp
# include "LCS.h"
#include <cstdio>
# include <vector>
#include <algorithm>
using namespace std;
/**
* 动态规划法求最长公共子序列长度矩阵C以及辅助矩阵
* 输入是两个序列
*/
void LCS::writeTable(Seq* seq1,Seq* seq2){
// 此处有一个小技巧，扩展了一行一列，由于后面会出现C[i-1][j] C[i][j-1]，扩展一行一列可以避免下标出现-1
int len1=seq1->len+1;
int len2=seq2->len+1;
//分配内存
C=new int*[len1];
src = new int*[len1];
for(int i=0;i<len1;i++){
C[i] = new int[len2];
src[i] = new int[len2];
}
//计算C矩阵和辅助矩阵src
for(int i=0;i<len1;i++){
for(int j=0;j<len2;j++){
if(i==0||j==0){ //自行扩展的一行一列，无意义
C[i][j]=0; //无实际用处
src[i][j]=0; //无实际用处
}else if(seq1->data[i-1]==seq2->data[j-1]){
C[i][j]=C[i-1][j-1]+1;
src[i][j]=0;
}else{
if(C[i-1][j]>C[i][j-1]){
C[i][j]=C[i-1][j];
src[i][j]=1;
}else if(C[i-1][j]<C[i][j-1]){
C[i][j]=C[i][j-1];
src[i][j]=2;
}else{
C[i][j]=C[i][j-1];
src[i][j]=3;
}
}
}
}
}
/**
* 判断子序列是否和已有的子序列重复
* 输入：LcsSet为已有的子序列集合，lcs为待加入的子序列
* 输出：若重复返回true，否则false
*/
bool isRepeat(vector<vector<int>>LcsSet,vector<int>lcs){
int flag=0;
for(int i=0;i<LcsSet.size();i++){
if(lcs.size()!=LcsSet.at(i).size()){
return true;
}
for(int j=0;j<lcs.size();j++){
if(lcs.at(j)!=LcsSet.at(i).at(j)){
flag=1;
}
}
if(flag==0){
return true;
}
flag=0;
}
return false;
}
/**
* 使用回溯法来找出所有的最长公共子序列，此处使用辅助矩阵src完成，用到递归编程技巧
* seq1是第一个序列，与C[i][j]的i对应；lcs是最长公共子序列；i,j是下标；Maxlen是最长公共子序列的长度；LcsSet是最长公共子序列的集合
*/
void LCS::createSubSeq(Seq* seq1,vector<int>lcs , int i,int j,int MaxLen,vector<vector<int>>&LcsSet){
if(i==0||j==0){
if(lcs.size()==MaxLen&&MaxLen>0){//已经回溯完成
reverse(lcs.begin(),lcs.end()); //翻转一下
if(!isRepeat(LcsSet,lcs)){ //去重
LcsSet.push_back(lcs); //加入
}
}
return;
}
switch (src[i][j]){
case 0://左上角
lcs.push_back(seq1->data[i-1]); //seq1对应i
createSubSeq(seq1,lcs,i-1,j-1,MaxLen,LcsSet);
break;
case 1://向上
createSubSeq(seq1,lcs,i-1,j,MaxLen,LcsSet);
break;
case 2://左
createSubSeq(seq1,lcs,i,j-1,MaxLen,LcsSet);
break;
case 3://左右皆可
createSubSeq(seq1,lcs,i-1,j,MaxLen,LcsSet);
createSubSeq(seq1,lcs,i,j-1,MaxLen,LcsSet);
break;
default:
break;
}
}
vector<vector<int>> LCS::getLCS(Seq* seq1,Seq* seq2){
if(seq1->len==0||seq2->len==0||seq1->data==nullptr||seq2->data==nullptr){
return vector<vector<int>>();
}
writeTable(seq1,seq2);
vector<int> lcs;
vector<vector<int>> LcsSet;
createSubSeq(seq1,lcs,seq1->len,seq2->len,C[seq1->len][seq2->len],LcsSet);
return LcsSet;
}
3.3 test.cpp
#include "LCS.h"
#include <cstdio>
#include <vector>
using namespace std;
void test1(){
LCS* lcs = new LCS();
Seq seq1 = Seq(new int[7]{1,8,2,3,7,8,2},7);
Seq seq2 = Seq(new int[9]{3,5,7,4,8,6,7,8,2},9);
vector<vector<int>> LcsSet= lcs->getLCS(&seq1,&seq2);
printf("nums of lcs : %d\n",LcsSet.size());
for(int i=0;i<LcsSet.size();i++){
for(int j=0;j<LcsSet.at(i).size();j++){
printf("%d ",LcsSet.at(i).at(j));
}
printf("\n");
}
}
int main(){
test1();
return 0;
}
3.4 Makefile
FLAG= -std=c++11
LIBS=
act:test.o LCS.o
g++ -o act test.o LCS.o $(FLAG) $(LIBS)
test.o:test.cpp
g++ -c test.cpp $(FLAG)
LCS.o:LCS.cpp LCS.h
g++ -c LCS.cpp $(FLAG)
4 测试结果
