最长公共子序列（动态规划）

1.最长公共子序列（不连续）

是指从给定序列中随意去掉一些字符后形成的子序列。(随意的意思是可以不连续的去掉一些个，也可以一个不去)

比如对于下面两个序列
a：abcbdb
b：acbbabdbb
它们的最长公共子序列：acbdb，长度5。

采用动态规划求解，定义F[ i, j ]为（$a_0,a_1,...a_{i-1}$）和（$b_0,b_1,...b_{j-1}$）的最长公共子序列长度。

因此根据定义查找过程分为下面的三种情况：

1. i=0 或 j=0 时，F[ i, j ]=0，对应边界情况。
2. a[ i-1]=b[ j-1]时，则进一步解决一个子问题，继续找出（$a_0,a_1,...a_{i-2}$）和（$b_0,b_1,...b_{j-2}$）的最长公共子序列长度。状态转移方程F[ i, j ]=F[ i-1, j-1 ]+1。
3. a[ i-1]≠b[ j-1]时，则划分成两个子问题，需要分别找出（$a_0,a_1,...a_{i-1}$）和（$b_0,b_1,...b_{j-2}$）以及（$a_0,a_1,...a_{i-2}$）和（$b_0,b_1,...b_{j-1}$）的最长公共子序列长度，并取二者最大值。对应状态转移方程F[ i, j ]=max(F[ i, j-1 ], F[ i-1, j ])。

public class LCS {
	char[] a; 						// 存放序列a
	char[] b; 						// 存放序列b
	int[][] dp;

	public LCS(String str1, String str2) {
		a = str1.toCharArray();
		b = str2.toCharArray();
		dp = new int[a.length + 1][b.length + 1];
	}

	// 获取最大长度
	public int getLenth() {
		for (int i = 1; i <= a.length; i++) {
			for (int j = 1; j <= b.length; j++) {
				if (a[i - 1] == b[j - 1]) {
					dp[i][j] = dp[i - 1][j - 1] + 1;
				} else {
					dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);
				}
			}
		}
		return dp[a.length][b.length];
	}

	// 根据dp数组找出子序列，其实是反向还原上面求长度的过程
	public StringBuilder getSubSequence() {
		int i = a.length;
		int j = b.length;
		int len = dp[i][j];

		StringBuilder subs = new StringBuilder("");
		while (len > 0) {
			if (dp[i][j] == dp[i - 1][j]) {
				i--;
			} else if (dp[i][j] == dp[i][j - 1]) {
				j--;
			} else {
				// 不满足上面两种情况时一定有dp[i][j]=dp[i-1][j-1]+1,对应a[i-1]=b[j-1]
				subs.append(a[i - 1]);
				i--;
				j--;
				len--;
			}
		}
		return subs.reverse();
	}

	public static void main(String[] args) {
		String str1 = "abcbdb";
		String str2 = "acbbabdbb";
		LCS ls = new LCS(str1, str2);
		System.out.println("长度：" + ls.getLenth());
		System.out.println("最长公共子序列：" + ls.getSubSequence());
	}
}

求解过程中的dp数组

因为求解过程中两层for循环并创建了一个二维数组，所以对于两个长度分别为 m, n 的序列，求解的时间和空间复杂度均为$O(mn)$。

2.最长公共子序列（连续）

还是上面两个序列，它们的最长公共连续子序列为：
a：abcbdb
b：acbbabdbb

这次定义F[ i, j ]为（$a_0,a_1,...a_{i-1}$）和（$b_0,b_1,...b_{j-1}$）的最长公共连续子序列长度，且子序列最后一个字符为$a_{i-1}或b_{i-1}$，也就是说这个连续子序列同时为两个序列的后半部分。

对此又可以分成下面三种情况：

1. 边界情况F[ i, j ]=0，当 i=0 或 j=0 时。
2. a[ i-1 ]=b[ j-1 ]，继续往前寻找，有F[ i, j ]=F[ i-1, j-1 ]+1。
3. a[ i-1 ]≠b[ j-1 ]，根据定义这个连续子序列必须以a[ i-1 ]或b[ j-1 ]结尾，这样的子序列不存在，所以有有F[ i, j ]=0。

public class LCS {
	char[] a; 						// 存放序列a
	char[] b; 						// 存放序列b
	int[][] dp;
	int len; 						// 保存最大长度
	int index; 						// 保存公共子序列的起始下标

	public LCS(String str1, String str2) {
		a = str1.toCharArray();
		b = str2.toCharArray();
		dp = new int[a.length + 1][b.length + 1];
	}

	public int getLenth() {
		for (int i = 1; i <= a.length; i++) {
			for (int j = 1; j <= b.length; j++) {
				if (a[i - 1] == b[j - 1]) {
					dp[i][j] = dp[i - 1][j - 1] + 1;
				}

				if (dp[i][j] > len) {
					len = dp[i][j];
					index = i - len;
				}
			}
		}
		return len;
	}

	public StringBuilder getSubSequence() {
		StringBuilder subs = new StringBuilder("");
		for (int i = 0; i < len; i++) {
			subs.append(a[index + i]);
		}
		return subs;
	}

	public static void main(String[] args) {
		String str1 = "abcbdb";
		String str2 = "acbbabdbb";
		LCS ls = new LCS(str1, str2);
		System.out.println("长度：" + ls.getLenth());
		System.out.println("最长连续公共子序列：" + ls.getSubSequence());
	}
}

求解过程中的dp数组：

时间和空间复杂度同样为$O(mn)$。