标签：JAVA LCS .. int char 算法 序列 lcs

最长公共子序列—动态规划算法（Longest Common Subsequence）

让我们来讨论如何使用动态规划算法来解决LCS问题。

LCS问题陈述：给定两个序列，找出两个序列中存在的最长子序列的长度。

子序列是以相同的相对顺序出现的序列，但不一定是连续的。例如，“abc”、“abg”、“bdf”、“aeg”、“'”acefg“等等都是“abcdefg”的子序列。所以一个长度为n的字符串有2^n个不同的可能子序列。

它是一个经典的计算机科学问题，是diff（一个输出两个文件之间差异的文件比较程序）的基础，在生物信息学中有着广泛的应用。

举例：

对于给定的字符串 “ABCDGH” 和 “AEDFHR”，其最长公共子序列为： “ADH”，最长公共子序列的长度为：3。
对于给定的字符串 “AGGTAB” 和 “GXTXAYB”，其最长公共子序列为：“GTAB”，最长公共子序列的长度为：4。

算法分析

这个问题的简单解决方案是生成两个给定序列的所有子序列，并找到最长的匹配子序列。根据时间复杂性，这个解是指数的。让我们看看这个问题如何具有动态规划（DP）问题的两个重要特性。

最优子结构

输入序列分别为长度m和n的X[0..m-1]和Y[0..n-1]。

设L（x[0..m-1]，y[0..n-1]）为两个序列X和Y的LCS的长度，下面是L（X[0..m-1]，Y[0..n-1]）的递归定义。

如果两个序列的最后一个字符匹配（或X[m-1]==Y[n-1]），则

L（X[0..m-1]，Y[0..n-1]）= 1+L（X[0..m-2]，Y[0..n-2]）

如果两个序列的最后一个字符不匹配（或X[m-1]！= Y[n-1）]

L（X[0..m-1]，Y[0..n-1]）=最大值（L（X[0..m-2]，Y[0..n-1]），L（X[0..m-1]，Y[0..n-2]））

例如：

1）考虑输入字符串“aggtab”和“gxtxayb”。最后一个字符与字符串匹配。因此，LCS的长度可以写为：

L（“aggtab”，“gxtxayb”）=1+L（“aggta”，“gxtxay”）。

 

2）考虑输入字符串“abcdgh”和“aedfhr”。最后一个字符与字符串不匹配。因此，LCS的长度可以写为：

L（“abcdgh”，“aedfhr”）=max（L（“abcdg”，“aedfhr”），L（“abcdgh”，“aedfh”））

因此，LCS问题具有最优的子结构性质，利用子问题的解可以解决主要问题。

重叠子问题

下面是LCS问题的简单递归实现。实现只遵循上面提到的递归结构。

package com.bean.algorithm.basic;

public class LongestCommonSubsequence {
	/* A Naive recursive implementation of LCS problem in java */

	/* Returns length of LCS for X[0..m-1], Y[0..n-1] */
	int lcs(char[] X, char[] Y, int m, int n) {
		if (m == 0 || n == 0)
			return 0;
		if (X[m - 1] == Y[n - 1])
			return 1 + lcs(X, Y, m - 1, n - 1);
		else
			return max(lcs(X, Y, m, n - 1), lcs(X, Y, m - 1, n));
	}

	/* Utility function to get max of 2 integers */
	int max(int a, int b) {
		return (a > b) ? a : b;
	}

	public static void main(String[] args) {
		LongestCommonSubsequence lcs = new LongestCommonSubsequence();
		String s1 = "AGGTAB";
		String s2 = "GXTXAYB";

		char[] X = s1.toCharArray();
		char[] Y = s2.toCharArray();
		int m = X.length;
		int n = Y.length;

		System.out.println("Length of LCS is" + " " + lcs.lcs(X, Y, m, n));
	}

}

输出结果：

Length of LCS is 4

上述幼稚的递归方法在最坏情况下的时间复杂度为O（2^n），当x和y的所有字符都不匹配（即lcs的长度为0）时，最坏情况发生。考虑到上述实现，下面是输入字符串“axyt”和“ayzx”的部分递归树。

 在上面的部分递归树中，LCS（“axy”，“ayz”）被求解两次。如果我们画出一个完整的递归树，那么我们可以看到有许多子问题被一次又一次地解决。因此，该问题具有重叠的子结构性质，可以通过动态规划算法来避免同一子问题的重新计算。下面是LCS问题的动态规划算法实现。

package com.bean.algorithm.basic;

public class LongestCommonSubsequence2 {
	/* Dynamic Programming Java implementation of LCS problem */
	/* Returns length of LCS for X[0..m-1], Y[0..n-1] */
	int lcs(char[] X, char[] Y, int m, int n) {
		int L[][] = new int[m + 1][n + 1];

		/*
		 * Following steps build L[m+1][n+1] in bottom up fashion. Note that L[i][j]
		 * contains length of LCS of X[0..i-1] and Y[0..j-1]
		 */
		for (int i = 0; i <= m; i++) {
			for (int j = 0; j <= n; j++) {
				if (i == 0 || j == 0)
					L[i][j] = 0;
				else if (X[i - 1] == Y[j - 1])
					L[i][j] = L[i - 1][j - 1] + 1;
				else
					L[i][j] = max(L[i - 1][j], L[i][j - 1]);
			}
		}
		return L[m][n];
	}

	/* Utility function to get max of 2 integers */
	int max(int a, int b) {
		return (a > b) ? a : b;
	}

	public static void main(String[] args) {
		LongestCommonSubsequence2 lcs = new LongestCommonSubsequence2();
		String s1 = "AGGTAB";
		String s2 = "GXTXAYB";

		char[] X = s1.toCharArray();
		char[] Y = s2.toCharArray();
		int m = X.length;
		int n = Y.length;

		System.out.println("Length of LCS is" + " " + lcs.lcs(X, Y, m, n));
	}

}

程序运行结果：

Length of LCS is 4

上述实现的时间复杂度为O（mn），比简单递归实现的最坏情况下的时间复杂度要好得多。

标签：JAVA,LCS,..,int,char,算法,序列,lcs
来源： https://blog.csdn.net/seagal890/article/details/89602682

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。