LCS 问题：最长公共子序列/最长公共子串

最长公共子序列

求两个字符串的最长公共子序列（Longest Common Sequence，简称 LCS），比如：

• A = “abcdefg”
• B = “acbeg"

那么这两个字符串的最长公共子序列便是：“aceg”。

对于这种求取”最“值的问题，非常容易想到会使用动态规划来求解。使用动态规划解决问题其实并没有多难，它只需要你做好两件事即可：

• 对状态做一个好的定义（即你的 dp 数组中的dp[i][j]代表着什么？）
• 跟据题意与刚刚定义好的状态，推导出状态转移方程

第一步的重要性，远远大于第二步，因为当你定义了一个好的状态之后，对于状态转移方程的推导将会变得非常容易。有些人认为动态规划难，其实就是有的时候对于状态的定义不是很好想。

接下来我们就按照这两步的顺序来看待这道LCS 问题。

一、对状态的定义：

这里，我们定义我们的 dp 数组如下所示：

int[][] dp = new dp[a.length() + 1][b.length() + 1]; 

长为字符串 a 的长度加 1，宽为字符串 b 的长度加 1.

dp[i][j]所代表的是当只取字符串 a 的 前 i 个字符.、只取字符串 b 的 前 j 个字符 时，这两个字符串的最长公共子序列的长度是多少（当 i 或 j 为 0 时，取前 0 个字符，当然不可能有公共子序列，此时dp[i][j]为 0）。

相信你也能想到了，最后的返回结果，只需要返回dp[a.length()][b.length()]即可。

二、状态的转移：

我们有了如上对状态的定义之后，接下来思考一下状态转移方程的推导。

判断字符串 a 的 第 i 个字符 与字符串 b 的 第 j 个字符 的关系。（注意标红部分，就是为了跟上面状态的定义做区分，上面的状态定义强调 ”前“，而这里的状态转移方程强调 ”第“）。

如果相等的话，那么dp[i][j] = dp[i-1][j-1] + 1，不解释，想不明白的话，往上翻多看看状态的定义。

如果不相等的话，那么dp[i][j]取dp[i-1][j]与dp[i][j-1]之间的最大值。

总结一下：

Java 实现代码如下

public class LongestCommonSubsequence {
	
	public static int LCS(String a,String b) {
		
		int[][] dp = new int[a.length() + 1][b.length() + 1];
		
		for(int i = 1; i <= a.length(); i++) {
			for(int j = 1; j <= b.length(); j++) {
				if (a.charAt(i - 1) == b.charAt(j - 1)) {
					dp[i][j] = dp[i - 1][j - 1] + 1;
				}else {
					dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
				}
			}
		}
		
		return dp[a.length()][b.length()];
	}
	
	public static void main(String[] args) {
		String a = "abcdefg";
		String b = "acbeg";
		System.out.println(a +" 与 " + b + " 的最长公共子序列长度为：" + LCS(a, b));
	}

}

控制台结果：

abcdefg 与 acbeg 的最长公共子序列长度为：4

 

最长公共子串

求两个字符串的最长公共子串（Longest Common Substring，另一种 LCS，换汤不换药）,与子序列不同的地方就在于，子串必须是连续的，比如：

• A = “abcdefg”
• B = “xabcy"

那么这两个字符串的最长公共子串便是：“abc”。延续上面最长公共子序列的思想，我们依然采取两步走的策略来看待这道题。

一、状态的定义：

这里，为了统一，我们定义我们的 dp 数组跟最长公共子序列的一样：

int[][] dp = new dp[a.length() + 1][b.length() + 1]; 

长为字符串 a 的长度加 1，宽为字符串 b 的长度加 1.

那么这次dp[i][j]又代表了什么呢？

它代表的含义：

• 以字符串 a 的第 i 个字符作为公共子串的结尾、并且仍需以字符串 b 的第 j 个字符作为公共子串的结尾，在这个前提下
• 在字符串 a 的前 i 个字符中，与字符串的前 b 个字符中，能形成最长的公共子串长度

上述对于 dp[i][j] 的描述可能有点难以理解，这里举两个小例子吧。假设字符串 a 是 “abcdefg”，字符串 b 是 “xabcy”.

那么，假如当前 i = 3，j = 4（这里为了好理解，我说的 i = 3 指的就是当前 i 指针指向的是第 3 个字符），此时字符串 a 就是 “abc”，字符串 b 就是 “xabc”，所以，此时dp[i][j]首先满足了第一个条件，即两个字符串末尾的字符是一样的，所以此时dp[i][j] = 3.

那么，如果 i = 4，j = 4 呢？此时字符串 a 就是 “abcd”，字符串 b 就是 “xabc”，二者的最后一个字符不相等，无法作为公共子串的结尾，所以此时 dp[i][j] = 0.

二、状态的转移：

通过上面对状态的定义，我们也能发现，有一个至关重要的点，就是第 i 个字符与第 j 个字符是否相等，这是我们推导状态转移方程的关键。

只要第 i 个字符不等于第 j 个字符，dp[i][j]肯定是 0 .

如果第 i 个字符与第 j 个字符相等，那么dp[i][j] = dp[i-1][j-1] + 1

总结一下：

返回结果，就是找 dp 数组中的最大值即可。

Java 实现：

    public static String solve(String a,String b) {
		
		int max = 0;
		int index = -1;
		
		int[][] dp = new int[a.length() + 1][b.length() + 1];
		for(int i = 1; i <= a.length(); i++) {
			for(int j = 1; j <= b.length(); j++) {
				if (a.charAt(i - 1) == b.charAt(j - 1)) {
					dp[i][j] = 1 + dp[i- 1][j - 1];
					if (max < dp[i][j]) {
						max = dp[i][j];
						index = i;
					}
				}
			}
		}
		
		String res = a.substring(index - max,index);
		return res;
	}

    public static void main(String[] args) {
		System.out.println(solve("abcdefg", "xabcy"));
	}

控制台打印结果：

abc