算法LCS,所有的最长公共子序列

//treenode.h #ifndef TREENODE_H #define TREENODE_H class TreeNode { friend class tree; public: TreeNode(char a=0) { data=a;
//构造函数
leftchild=0; rightchild=0; parent=0; } TreeNode * leftchild; TreeNode * rightchild; TreeNode* parent; char data; }; #endif //构造树 //tree.h #ifndef TREE_H #define TREE_H #include "treenode.h" #include <string> #include "stack.h" const int m=7,n=6; //默认 x 的长度为 7，y 的长度为 6 int i=0,j=0; int exsit=0; //记录字符串数组有几个元素 class tree { public: tree(int b[m+1][n+1],string x,int i,int j); TreeNode* LCS(int b[m+1][n+1],string x,int i,int j); //构造树 void inorder(); void inorder(TreeNode*); //中序遍历，找出所有的叶子节点 void con_parent();//遍历树，找出每个节点的 parent void tranverse(TreeNode*);//从叶子节点遍历到根，找出 LCS void output(); //输出所有的 LCS private: TreeNode *root;//根 Stack<TreeNode*> stack;//用栈来记录叶子节点 string *t;//字符串数组记录不同的 LCS }; tree::tree(int b[m+1][n+1],string x,int i,int j) { t=new string[n];//字符串数组最长为 min{x.length,y.length} for (int y=0;y<n;y++) { t[y]=""; } root=LCS(b,x,i,j);//递归构造 } TreeNode* tree::LCS(int b[m+1][n+1],string x,int i,int j) { if (i==0||j==0)
1 2 3 4 5 6 7
↑ ↑ ↑↖ ↖ A 0 0 0 0 1←1 1 ↖ ↑↖ B 0 1←1←1 1 2←2 ↑ ↑↖ ↑ ↑ C 0 1 1 2 ←2 2 2 ↖ ↑ ↑ ↑↖ B 0 1 1 2 2 3←3 ↑↖ ↑ ↑ ↑ ↑ D 0 1 2 2 2 3 3 ↑ ↑ ↑↖ ↑↖ A 0 1 2 2 3 3 4 ↖ ↑ ↑ ↑↖ ↑ B 0 1 2 2 3 4 4
0 若i 0或j 0 C[i 1, j 1] 1 若i, j 0且 xi y j C[i,j]= max{ C[i 1, j ], C[i, j 1]} 若i, j 0且 xi
y j
为了构造出 LCS，使用一个 mn 的二维数组 b， b[i,j]记录 C[i,j]是通过哪一个子问题的值求得的, 以决定搜索的方向： 若 X[i]=Y[j]，则 b[i,j]中记入“↖”（亦可不记） ； 若 X[i]Y[j]且 C[i-1,j] ≥ C[i,j-1]，则 b[i,j]中记入“↑”； 若 X[i]Y[j]且 C[i-1,j] < C[i,j-1]，则 b[i,j]中记入“←”； e.g. 对于 X=<A,B,C,B,D,A,B>，Y=<B,D,C,A,B,A>， 求出的各个 C[i,j]与 b[i,j]如下图： 0 1 2 3 4 5 6 yj B D C A B A 0 xi 0 0 0 0 0 0 0
//从叶子往根遍历时找的路线
{ TreeNode* a=new TreeNode('$');//默认将节点值赋为’$’ return a; } if (b[i][j]==0) { TreeNode* a=new TreeNode(x[i]); //存在字符相等，创造新节点，并赋值 a->leftchild=LCS(b,x,i-1,j-1);//左子树继续构造 return a; } else if (b[i][j]==1) { return LCS(b,x,i-1,j);//往上面走，不创造新节点，继续递归 } else if (b[i][j]==-1) { return LCS(b,x,i,j-1);//往左面走，不创造新节点，继续递归 } else { //遇到两个方向的点，创造新节点，并默认赋值为’#’,递归构造 子树。 TreeNode* a=new TreeNode('#'); a->leftchild=LCS(b,x,i-1,j); a->rightchild=LCS(b,x,i,j-1); return a; } } void tree::inorder() { inorder(root); } //找出所有的叶子节点用栈来记录 void tree::inorder(TreeNode* current) { if(current) { inorder(current->leftchild); if(current->data=='#') stack.add(current); inorder(current->rightchild); } } 遍历树，找出每个节点的 parent void tree::con_parent() { int i=0; Stack<TreeNode*> s; TreeNode* currentNode=root; while(1) 左子树和右
Hale Waihona Puke { while(currentNode) { s.add(currentNode); TreeNode* pp=currentNode; if (currentNode->leftchild) { currentNode->leftchild->parent=pp; } currentNode=currentNode->leftchild; } if (s.IsEmpty()) return; currentNode=s.Top(); cout<<currentNode->data<<" "; TreeNode* pp=currentNode; if(currentNode->rightchild) { currentNode->rightchild->parent=pp; } currentNode=currentNode->rightchild; } } //从叶子遍历到根，找出 LCS void tree::tranverse(TreeNode* leaf) { TreeNode* currentNode=leaf; string temp=""; bool flag=true; while(currentNode->parent) { if (currentNode->data!='#'&&currentNode->data!='$') { temp=temp+currentNode->data+" "; } currentNode=currentNode->parent; } if(root->data!=’#’)//若根有非真值添加到其中去 { temp+=root->data; } //看 LCS 若有重复的，不存入 string 数组中， for (int count=0;count<m;count++) { if (temp==t[count]) { flag=false; break; } } if (flag) { cout<<temp<<"\n"; t[exsit++]=temp;
②找出所有路径的思想： 仅用“↑” ，“←” ，“↖”是搜索不到所有的 LCS 的，因为 C[i-1,j]≥C[i,j-1]， 我们没有区分 C[i-1,j]>C[i,j-1]还是 C[i-1,j]＝C[i,j-1] 此时我们只是在单方向搜索， 就像是图的深度优先搜索， 走到底， 找出一条路径。为了找出所有的 LCS，我们将 C[i-1,j]≥C[i,j-1]记做 “←↑” 。 同时用遍历 b[i,j]构造出一棵树 tree， “↑”的方向记做节点的左子 树，右子树为空，“←”的方向记做节点的右子树，左子树为空，“↖” 的方向开辟新的节点，并对其赋值， “←↑”记做节点的左子树和右子 树。当树构造完毕时，我们从叶子节点开始遍历，一直到根为止，即 找出所有的 LCS。 注意：此时找出的所有的 LCS 可能有重复的，所以用一个字符 串数组来记录不同的 LCS。容易证明该字符数组最长为 min{x.length,y.length}; 三、解决方案 为了方便， 程序中将“↑” 记做 1， “←”记做-1 ， “↖”记做 0， “←↑” 记做 2.
所有的最长公共子序列（LCS）
一、 问题描述 子序列的概念： 设 X = <x1, x2,┅, xm>， 若有 1≤i1<i2< ┅ <ik≤m， 得 Z=< z1, z2,┅, zk> = <xi1, xi2,┅, xik>， 则称 Z 是 X 的子序列，记为 Z<X。e.g. X=<A,B,C,B,D,A,B>, Z=<B,C,B,A>, 则有 Z<X。 公共子序列的概念： 设 X，Y 是两个序列，且有 Z<X 和 Z<Y，则称 Z 是 X 和 Y 的公共 列。 最长公共子序列的概念： 若 Z<X，Z<Y， 且不存在比 Z 更长的 X 和 Y 的公共子序列， 则称 Z 是 X 和 Y 的最长公共子序列，记为 ZLCS(X , Y)。 但是 LCS 不是只有一个， 最长公共子序列往往不止一个。 e.g. X=<A,B,C,B,D,A,B>, Y=<B,D,C,A,B,A>, 则 Z=<B,C,B,A>, Z’=<B,C,A,B>, Z’’=<B,D,A,B>均属于 LCS(X , Y) ，即 X,Y 有 3 个 LCS。 本文描述如何寻找所有的 LCS 二、问题分析 ①先描述寻找一个 LCS 的思想： 记 Xi=﹤x1，…，xi﹥即 X 序列的前 i 个字符 (1≤i≤m)（前缀） Yj=﹤y1，…，yj﹥即 Y 序列的前 j 个字符 (1≤j≤n)（前缀） 假定 Z=﹤z1，…，zk﹥∈LCS(X , Y)。 若 xm=yn（最后一个字符相同） ，则不难用反证法证明： 该字符必是 X 与 Y 的任一最长公共子序列 Z （设长度为 k） 的最后一 个字符，即有 zk = xm = yn。且显然有 Zk-1∈LCS(Xm-1 , Yn-1)即 Z 的前 缀 Zk-1 是 Xm-1 与 Yn-1 的最长公共子序列。 若 xm≠yn，则亦不难用反证法证明： 要么 Z∈LCS(Xm-1, Y)，要么 Z∈LCS(X , Yn-1)。由于 zk≠xm 与 zk≠yn 其中至少有一个必成立，因此：若 zk≠xm 则有 Z∈LCS(Xm-1 , Y)，若 zk≠yn 则有 Z∈LCS(X , Yn-1)。 ∴若 xm=yn，则问题化归成求 Xm-1 与 Yn-1 的 LCS， （LCS(X , Y)的长 度等于 LCS(Xm-1 , Yn-1)的长度加 1） 若 xm≠yn，则问题化归成求 Xm-1 与 Y 的 LCS 及 X 与 Yn-1 的