最长公共子序列算法 java,算法学习——java实现最长公共子序列,

算法学习——java实现最长公共子序列学习——java实现最长公共子序列的算法，

实验目的：

输入两个同类型的序列，用动态规划的方法计算它们最长的公共子序列的长度和序列。

(推荐教程： Java视频教程

思考：

1.首先，使用二维数组存储最长公共子序列的长度，并记录每个值的状态

2.根据记录值的状态，递归计算最长的公共子序列

3.递归方程：

代码实现：

Package c最长公共子序列；

导入Java . util . scanner；

/**

* @作者德拉科

* @参见最长公共子序列(最长公共缺失)

* @版本

* @ date-time 2020-04-27-4:2:36。

*/

LCS公开课

公共静态void main(String[] args) {

//测试字符串：ABCBDAB BDCABA

扫描仪扫描仪=新扫描仪(system . in)；

System.out.println(‘注意：第一个字符串比第二个字符串长’)；

System.out.print(‘请输入第一个字符串：’)；

string 1=scanner . next()；

System.out.print(‘请输入第二个字符串：’)；

string string 2=scanner . next()；

String str1=string1

String str2=string2

//String str 1=’ ABCBDAB ‘；

//String str 2=’ BDCABA ‘；

int[][]c=GetSubstingMatriX(str 1，str 2)；

String[][] b=getTrace(str1，str 2)；

System.out.println(‘长度矩阵：’)；

show(c)；

system . out . println()；

System.out.println(‘方向矩阵：’)；

showforsting(b)；

System.out.println(‘最长公共子序列的长度：’ c[str 1 . length()][str 2 . length()])；

string SMax=str 1 . length()str 2 . length()？str1 : str2//选择最长的字符串，因为你要取出最大的子字符串

string SMin=str 1 . length()str 2 . length()？str1 : str2//选择最小的字符串

System.out.print(‘最长的公共子字符串：’)；

print(b，sMax，sMax.length()，SMin . length())；

{}

/**

* @参见找出子序列的矩阵，其中最后一行和最后一列是最长子序列的长度

* @param x第一个字符串

* @param y第二个字符串

* @返回长度矩阵

*/

public static int[][]GetSubscriptingStrix(String x，String y) {

int Xlen=x . length()1；//添加1是因为第一个被初始化为0

int YLen=y . length()1；

int rLen=xLen yLen？xLen : yLen//大字符串按行排列

int cLen=xLen yLen？xLen : yLen//小字符串按列排列

int[][]c=new int[RLen][CLen]；//保存矩阵c的状态

for(int I=1；i rLeni ) {

for(int j=1；j cLenj ) {

if(x . CharaT(I-1)=y . CharaT(j-1)){

//相等，对角线1

c[I][j]=c[I-1][j-1]1；

} else if (c[i – 1][j]=c[i][j – 1]) {

//不相等，请选择较大的

c[I][j]=c[I-1][j]；

} else {

c[I][j]=c[I][j-1]；

{}

{}

{}

返回c；//长度矩阵

{}

/**

* @see记录每个值的状态，便于回溯递归

* @param x第一个字符串

* @param y第二个字符串

* @返回方向矩阵

*/

公共静态字符串[][] getTrace(字符串x，字符串y) {

int Xlen=x . length()1；

int YLen=y . length()1；

//为矩阵c和b设置行和列。

int rLen=xLen yLen？xLen : yLen//大字符串按行排列

int cLen=xLen yLen？xLen : yLen//小字符串按列排列

int[][]c=new int[RLen][CLen]；

String[][]b=new String[RLen][CLen]；

for(int I=1；i rLeni ) {

for(int j=1；j cLenj ) {

if(x . charat(I-1)==y . charat(j-1)){//等于

c[I][j]=c[I-1][j-1]1；

b[I][j]=’ \ \ \ \ ‘；//指向左上角

} else if(c[I-1][j]=c[I][j-1]){//不相等

//当上述值较大时

c[I][j]=c[I-1][j]；

b[I][j]=’ | ‘；//指向顶部

} else {

//当下列值较大时

c[I][j]=c[I][j-1]；

b[I][j]=’ —— ‘；//指向左边

{}

{}

{}

返回b；//方向矩阵

{}

/**

* @参见递归实现回溯，然后打印出最长的公共子序列

* @param b方向矩阵

* @param s长字符串

* @param i较长字符串的长度

* @param j较短字符串的长度

*/

public static void print(String[][]b，String s，int i，int j) {

//递归终止的条件

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

返回；

{}

//判断递归的条件

if (b[i][j]。等于(‘ \ \ \ \ ‘){

//遇到斜线，递归到左上角

print(b，s，i – 1，j-1)；

系统。出去。print(s . charat(I-1)’ ‘)；

} else if (b[i][j]).等于(“|”)

//遇到竖线，递归到上边

print(b，s，i – 1，j)；

} else if (b[i][j]).equals(‘ —— ‘){

//遇到横线，递归到左边

print(b，s，I，j-1)；

{}

{}

/**

* @参见打印二维数组

* @param b一个二维数组

*/

public static void show(int[][]b){

for(int w=0；w b。长度；w ) {

for(int p=0；p b[w].长度；p ) {

系统。出去。print(b[w][p]’ \ \ t ‘)；

if (p==b[w]).长度- 1) {

系统。出去。println()；

{}

{}

{}

{}

/**

* @参见打印字符串的二维数组

* @param b一个字符串的二位数组

*/

public static void showforsting(String[][]b){

for(int w=1；w b。长度；w ) {

系统。出去。print(‘ \ \ t ‘)；

for(int p=1；p b[w].长度；p ) {

系统。出去。print(b[w][p]’ \ \ t ‘)；

if (p==b[w]).长度- 1) {

系统。出去。println()；

{}

{}

{}

{}

{}运行结果：