LCS算法的两种JAVA实现方式

http://blog.csdn.net/dylgsy/article/details/8235778

http://blog.csdn.net/v_july_v/article/details/6695482

给定字符串A,B

Solution  I:

1.构造数组 c i  j 描述A串的前i位和B串的前J位的LCS长度

2.构造数组 trace  i  j  描述max相应位置得到的长度是由哪一步得出的

c的构造方法根据下列规则



trace的构造如下图所示



END和START表示该处是直接得到的结果，没有前置步骤。

END表示LCS=0，START表示LCS=1

其余的根据箭头方向来看就比较好理解了。

获得结果时从上往下遍历即可，总的时间复杂度O(mn)+O(m+n)

代码如下

//枚举

enum DIRECTION{
<span style="white-space:pre">		</span>LEFT,UP,UPLEFT,START,END
<span style="white-space:pre">	</span>}

//核心算法

...

for(int i=0;i<ch1.length;i++)
for(int j=0;j<ch2.length;j++){
if(ch1[i]!=ch2[j]){
if(i>0&&j>0){
if(c[i-1][j]>c[i][j-1]){
trace[i][j]=DIRECTION.LEFT;
c[i][j]=c[i-1][j];
}
else{
trace[i][j]=DIRECTION.UP;
c[i][j]=c[i][j-1];
}
}else{
if(i>0){
trace[i][j]=DIRECTION.LEFT;
c[i][j]=c[i-1][j];
}else if(j>0){
trace[i][j]=DIRECTION.UP;
c[i][j]=c[i][j-1];
}else{
trace[i][j]=DIRECTION.END;
c[i][j]=0;
}
}
}else{
if(i==0||j==0){
trace[i][j]=DIRECTION.START;
c[i][j]=1;
}
else{
trace[i][j]=DIRECTION.UPLEFT;
c[i][j]+=c[i-1][j-1]+1;
}
}
}
//calculate
StringBuilder sb=new StringBuilder("");
int i=ch1.length-1,j=ch2.length-1;
end:
for(;i>=0&&j>=0;)
switch(trace[i][j]){
case UP:j--;break;
case LEFT:i--;break;
case UPLEFT:sb.append(ch1[i]);j--;i--;break;
case START:sb.append(ch1[i]);break end;
case END:break end;
}
//输出(sb.reverse().toString());
//输出(c[ch1.length-1][ch2.length-1]);

Solution II:

构造矩阵L(p,m)

算法实现方式不复杂，原理并不是很明了，这里把过程详细描述一下，希望可以得到一些讨论。

首先假设A串长度不超过B串。

构造基于A串长度的方阵L(i,k)表示A[1..i]中长度为k的子串在B中最小位置（这里认为字符串的位置是最末尾字符的位置），如果不存在这样的子串，则长度为无穷（MAX）。

显然，LCS={k|L(A.length,k)!=MAX}max。

过程也是从下至上递推的。

首先初始化L(1,i)，注意L(i,k)=k时，L(i,k+1),L(i,k+2)....均为k，因为相同长度的子串，位置最小的一定是从头开始的那一个。

然后循环，遍历并生成L，规则如下：

i>k时，显然，L(i,k)=MAX

如果L(i-1,k-1)存在，则

从L(i-1,k-1)+1开始遍历到B串结尾，遍历的位置记为j，若B[j]=A[i]，则：

比较L(i-1,k)（如果存在）和J的大小，较小的一个即为所求的L(i,k)

这里因为上一步所求的结果中，L(i-1.k-1)实际上可以看做L(i,k)的一部分，因为如果前者(长度为k-1的LCS)存在的话，在L(i-1.k-1)所得的位置往后遍历，遇到与A[i]相等的字符，一定可以与前者组成长度为k的LCS。

L(i,k)=k时，L(i,k+1),L(i,k+2)....均为k，原因同上。

对于一个k，遍历i一遍后，所有L(i,k)均不存在，则k-1，即最后一次所得的k，即为我们要的LCS长度。

B[L(1,m-p+1)]B[L(2,m-p+2)]…B[L(k,i)]即为LCS。

代码如下：

int result=0;
//Li(k)
int[][] L=new int[char1.length+1][char1.length+1];
//init L[k][i] k=1
for(int i=1;i<=char1.length;i++){
L[1][i]=1+str2.indexOf(String.valueOf(char1[i-1]));
if(L[1][i]==1){
for(int j=i+1;j<=char1.length;j++)
L[1][j]=1;
break;
}
}
int nullCount=0;
for(int k=2;k<=char1.length;k++){
nullCount=0;
for(int i=1;i<=char1.length;i++){
if(i<k){
L[k][i]=MAX;
nullCount++;
continue;
}
int min=MAX;
if(L[k-1][i-1]!=MAX){
if(L[k][i-1]!=MAX)
min=L[k][i-1];
for(int j=L[k-1][i-1]+1;j<=char2.length;j++)
if(char2[j-1]==char1[i-1]){
min=j<min?j:min;
break;
}
}
L[k][i]=min;
if(L[k][i]==k){
for(int j=i+1;j<=char1.length;j++)
L[k][j]=k;
break;
}
if(L[k][i]==MAX)
nullCount++;
}
if(nullCount==char1.length){
result=k-1;
break;
}
}
result=result==0?char1.length:result;
StringBuilder sb=new StringBuilder();
int i=char1.length,k=result;
while(k>0&&i>0)
sb.append(char2[L[k--][i--]-1]);
sb.reverse();