JavaScript 实现最长子字符串（LCS）

目标：

找出两个 字符串 X = 'CGATAATTGAGA' 和 Y = 'GTTCCTAATA' 的最长公共子序列。用动态规划求解（解不唯一？）。

首先建立一个表 table = table[row,col] = table[12+1,10+1];为什么多一格呢？ 

先初始化每个单元格的值为0；

然后，遍历行和列：

当X[row] = Y[col]时，table[row,col] = table[row-1,col-1]+1;

当X[row] <> Y[col]时，table[row,col] = Math.max(table[row,col-1],table[row-1,col]);

这样就构建出一个下面的表：

        G  T  T  C  C  T  A  A  T  A       

   [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]    

C [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1]    

G [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]    

A [0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2]    

T [0, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3]    

A [0, 1, 2, 2, 2, 2, 2, 3, 3, 3, 4]    

A [0, 1, 2, 2, 2, 2, 2, 3, 4, 4, 4]    

T [0, 1, 2, 3, 3, 3, 3, 3, 4, 5, 5]    

T [0, 1, 2, 3, 3, 3, 4, 4, 4, 5, 5]    

G [0, 1, 2, 3, 3, 3, 4, 4, 4, 5, 5]    

A [0, 1, 2, 3, 3, 3, 4, 5, 5, 5, 6]    

G [0, 1, 2, 3, 3, 3, 4, 5, 5, 5, 6]    

A [0, 1, 2, 3, 3, 3, 4, 5, 6, 6, 6]

通过这个表来找出LCS，LCS由表的下标给出，将这些下标放入一个数组L

从表的最后开始回溯：

row = 13, col = 11;

1、table[13,11]对应的行和列的字符相等，将（13,11）放入L，row-=1，col-=1；

2、table[12,10]对应的行和列的字符不相等，比较table[11,10]和table[12,9]

　　2.1 table[11,10] > table[12,9]，i -= 1;

　　2.2 否则 j -= 1;

重复1、2

实现：

/*
  initial a row*col table
  return a table
*/
function initTable(row,col){
    var table = [];
    
    for(var i=0;i<row+1;i++){
	if(!table[i])table[i] = [];
	for(var j=0;j<col+1;j++){
	    if(!table[i][j])table[i][j] = [];
	    table[i][j] = 0;
	}
    }
    return table;
}
/*
  compute the path index of the table
  return array contain the index of s1 and s2
*/
function computeLCSIndex(s1,s2,table){
    var i = s1.length,
    j = s2.length,
    L1=[];
    
    while(i>0 && j>0){
	//console.log(i,j);
	if(s1[i-1] == s2[j-1]){
	    //console.log(i,j);
	    L1.push([i,j]);
	    j -=1;
	    i -=1;
	}else{
	    if(!table[i-1]){
		console.log(i);	    
		break;
	    }

	    if(table[i-1][j] > table[i][j-1]){
		i -= 1;
	    }else{
		j -= 1;
	    }
	}
    }

    return L1;
}
/*
  get LCS from s1,or s2 from LCS index
 */
function LCS(s1,s2,L1){
    //console.log(L1 = L1.reverse());
    L1 = L1.reverse();
    var LCS = "";
    for(var j=0;j<L1.length;j++){
	LCS+=(s2[L1[j][1]-1]);
    }
    //console.log(LCS);
    return LCS;
}

function diff(s1,s2){
    var len1 = s1.length,
    len2 = s2.length,
    table,
    L1;//LCS index of s1
    
    table  = initTable(len1,len2);

    for(k=1;k<len1+1;k++){
	for(l=1;l<len2+1;l++){
	    if(s1[k-1] === s2[l-1]){
		//console.log("k:"+k+",l:"+l+table[k-1][l-1]);
		table[k][l] = table[k-1][l-1] + 1;
	    }else{
		//console.log("k:"+k,"l:"+l);
		table[k][l] = Math.max(table[k][l-1],table[k-1][l]);
	    }
	}
    }
    /*
    table.forEach(function(i){
	console.log(i);
    });
    */

    L1 = computeLCSIndex(s1,s2,table);
    return L1;
}

var debug = true;
if(debug){
    var A = 'CGATAATTGAGA',
    B = 'GTTCCTAATA';
    var L = diff(A,B);
    
    var s = LCS(A,B,L);
    console.log(s);

    var X = ["Cqdf", "G23", "A", "T", "A", "A", "T", "T", "G", "A", "G", "A"],
    Y = ["G2", "Tsfj", "T", "C", "C", "T", "A", "A", "T", "A"];

    var L2 = diff(X,Y);
    var s2 = LCS(X,Y,L2);

    console.log(s2);
}

通常是以单个字符作为比较的“元”，若以多个字符作为比较的元，那么输入的参数为数组即可：