这个问题的叙述太多了，就不重复了。这里我只是球出了LCS的长度，事实上，长度还是非常有用的，如判断两个字符串相似程度。主要是想说明的是，利用递归来求解。非常方便。今天下午了试了3个题，一个回文数，一个LCS长度，一个POJ1088:递归求解动态规划很好用。前提是要选择正确的量和找出状态转换表达式。其实，状态转换表达式就是一个递归的。为了得到状态转换表达式，务必要选择正确的数据量表示意义。就是下面的C矩阵 。

C[i][j]含义：

两个序列:

X= (x0，x1，……xm- 1);

Y = (y0,y1……，yn - 1);

c[i][j]:序列Xi和Yj的一个LCS长度，序列Xi=(x0，x1……xi)，序列Yj=(y0,y1……yj)。

那么有如下递推

(1) i = 0或者j = 0,c[i][j] = 0;

(2) x(i-1) = y(j-1)  c[i][j] = c[i - 1][j - 1] + 1; //这里要注意的是，x[0...m-1]，而C矩阵从1开始的。

(3) xi != yj c[i][j] = max(c[i][j - 1],c[i - 1][j])

代码及其测试结果如下：

package myalgorithm;

import java.util.Scanner;

public class MyLCS {

private static char[] x;

private static char[] y;

private static char[] strX;

private static char[] strY;

private static int[][] c;

private static void init(){

Scanner sc = new Scanner(System.in);

x = sc.next().toCharArray();

y = sc.next().toCharArray();

c = new int[x.length + 1][y.length + 1];

for (int i = 0; i < x.length + 1; i++)

c[i][0] = 0;

for (int j = 0; j < y.length + 1; j++)

c[0][j] = 0;

for (int i = 1; i < x.length + 1; i++)

for(int j = 1; j < y.length + 1; j ++){

c[i][j] = computeMatrixC(i,j);

}

}

/**

* @param i

* @param j

* @return

*/

private static int computeMatrixC(int i, int j) {

if (i == 0 || j == 0){

return 0;

}

else

if (x[i - 1] == y[j - 1])

return c[i - 1][j - 1] + 1;

else

return c[i][j - 1] > c[i - 1][j] ? c[i][j - 1] : c[i - 1][j];

}

//在C矩阵中找到最大的C值

private static int getValue(){

int max = 0;

for (int i = 0; i < x.length + 1; i ++)

for(int j = 0; j < y.length + 1; j++)

if (c[i][j] > max)

max = c[i][j];

return max;

}

//打印C矩阵

private static void printC(){

for (int i = 0; i < x.length + 1; i ++)

for(int j = 0; j < y.length + 1; j++){

System.out.print(c[i][j] + " ");

if (j > 0 && j % (y.length) == 0){

System.out.println();

}

}

}

/**

* @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

init();

System.out.println(getValue());

printC();

}

}

abcbdab

bdcaba

4

0  0  0  0  0  0  0

0  0  0  0  1  1  1

0  1  1  1  1  2  2

0  1  1  2  2  2  2

0  1  1  2  2  3  3

0  1  2  2  2  3  3

0  1  2  2  3  3  4

0  1  2  2  3  4  4