最长公共子序列—动态规划算法（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），比简单递归实现的最坏情况下的时间复杂度要好得多。