动态规划java LCS_Java-LCS最长公共子序列（动态规划实现）

一个序列S任意删除若干个字符得到新序列T，则T称为S的子序列。若两个序列X和Y的公共子序列中，长度最长的那个字序列称为X和Y的最长公共子序列(LCS)。

Xi表示字符串的前i个字符，Yj表示字符串的前j个字符，它们的公共子序列记为：LCS(X,Y)，即Z=。利用动态规划来处理该问题，此时分为两种情况：

1)Xm == Yn(最后一个字符相同)，则Xm与Yn的最长公共子序列Zk的最后一个字符必定相同，即：Xm == Yn == Zk。此时的表达式为：

LCS(Xm, Yn) = LCS(Xm-1, Yn-1) +Xm             (**公式一**)

2)Xm != Yn(最后一个字符不相同)，则Xm与Yn的最长公共子序列Zk的最后一个字符就存在两种肯能，即：Xm == Zk 或者 Yn == Zk。此时的表达式存在两种情况，如下：

LCS(Xm, Yn) = LCS(Xm-1, Yn) 或者 LCS(Xm, Yn) = LCS(Xm, Yn-1)。则最终的表达式为：

LCS(Xm, Yn) = MAX{LCS(Xm-1, Yn), LCS(Xm, Yn-1)}     (**公式二**)

在寻找最长公共子序列的过程中利用数组Array来记录Xi和Yj的最长公共子序列的长度。当i=0或j=0时，Array数组记录为0。当i>0,j>0并且Xi==Yj时，利用公式一，当i>0,j>0,并且Xi！= Yj时，利用公式二。得到如下公式：

Array(i,j) = 0;                                          当i=0或者j=0;

Array(i,j) = Array(i-1,j-1);                        当i>0,j>0&&Xi==Yj;

Array(i,j) = max{Array(i-1,j),Array(I,j-1)}      当i>0,j>0&&Xi！=Yj

package 字符串;

import java.util.Scanner;

import java.util.Stack;

/**

* 任意输入两个字符串，求出这两个字符串的公共子序列

* */

public class 最长公共子序列 {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

String x = sc.next();

String y = sc.next();

getLCS(x,y);

}

public static void getLCS(String x, String y){

char[] s1 = x.toCharArray();

char[] s2 = y.toCharArray();

int[][] array = new int[x.length()+1][y.length()+1];//此处的棋盘长度要比字符串长度多加1，需要多存储一行0和一列0

for(int j = 0; j < array[0].length; j++){//第0行第j列全部赋值为0

array[0][j] = 0;

}

for(int i = 0; i < array.length; i++){//第i行，第0列全部为0

array[i][0] = 0;

}

for(int m = 1; m < array.length; m++){//利用动态规划将数组赋满值

for(int n = 1; n < array[m].length; n++){

if(s1[m - 1] == s2[n - 1]){

array[m][n] = array[m-1][n-1] + 1;//动态规划公式一

}else{

array[m][n] = max(array[m -1][n], array[m][n -1]);//动态规划公式二

}

}

}

//for(int m = 0; m < array.length; m++){//将数组赋满值,这样可以从右下角开始遍历找出最大公共子序列

//for(int n = 0; n < array[m].length; n++){

//System.out.print(array[m][n]);

//}

//System.out.println();

//}

Stack stack = new Stack();

int i = x.length() - 1;

int j = y.length() - 1;

while((i >= 0) && (j >= 0)){

if(s1[i] == s2[j]){//字符串从后开始遍历，如若相等，则存入栈中

stack.push(s1[i]);

i--;

j--;

}else{

if(array[i+1][j] > array[i][j+1]){//如果字符串的字符不同，则在数组中找相同的字符，注意：数组的行列要比字符串中字符的个数大1，因此i和j要各加1

j--;

}else{

i--;

}

}

}

while(!stack.isEmpty()){//打印输出栈正好是正向输出最大的公共子序列

System.out.print(stack.pop());

}

}

public static int max(int a, int b){//比较(a,b)，输出大的值

return (a > b)? a : b;

}

}