最长公共子序列问题-动态规划-样本对应模型

最长公共子序列问题

题目：两个字符串的最长公共子序列问题（样本做行，样本做列）

给定两个字符串str1和str2，
返回这两个字符串的最长公共子序列长度

比如 ： str1 = “ab123c45d6ef”,str2 = “ks1234tz56”
最长公共子序列是“123456”，所以返回长度6

public static int longestCommonSubsequence1(String s1, String s2) {
		if (s1 == null || s2 == null || s1.length() == 0 || s2.length() == 0) {
			return 0;
		}
		char[] str1 = s1.toCharArray();
		char[] str2 = s2.toCharArray();
		// 尝试
		return process(str1, str2, str1.length - 1, str2.length - 1);
	}

先将对应的字符串转换为我们的 char字节，这样不区分大小就可以确定是不是最长公共子序列了。

我们先写尝试第一步：

public static int process(char[] str1, char[] str2, int i, int j) {
    // 当i等于0的时候
 	if (i == 0) {
			if (str1[i] == str2[j]) {
				return 1;
			} else {
				return process(str1, str2, i, j - 1);
       }
}

public static int process(char[] str1, char[] str2, int i, int j) {
    // 当j等于0的时候
 	if (j == 0) {
			if (str1[i] == str2[j]) {
				return 1;
			} else {
				return process(str1, str2, i - 1, j);
		}
}

当然还有我们最常见的两者都等于0的时候

if (i == 0 && j == 0) {
   return str1[i] == str2[j] ? 1 : 0;
}

除去这种情况，就是 i != 0的时候并且 j != 0 的时候

 	// i != 0 && j != 0  这个时候就让他们一个个的去递归找出每种情况，都取一个最大值，最后返回得到结果
   int p1 = process(str1, str2, i - 1, j);
   int p2 = process(str1, str2, i, j - 1);
   int p3 = str1[i] == str2[j] ? (1 + process(str1, str2, i - 1, j - 1)) : 0;
   return Math.max(p1, Math.max(p2, p3));

全部代码：

public static int longestCommonSubsequence1(String s1, String s2) {
   if (s1 == null || s2 == null || s1.length() == 0 || s2.length() == 0) {
      return 0;
   }
   char[] str1 = s1.toCharArray();
   char[] str2 = s2.toCharArray();
   // 尝试
   return process(str1, str2, str1.length - 1, str2.length - 1);
}

public static int process(char[] str1, char[] str2, int i, int j) {
   if (i == 0 && j == 0) {
      return str1[i] == str2[j] ? 1 : 0;
   } else if (i == 0) {
      if (str1[i] == str2[j]) {
         return 1;
      } else {
         return process(str1, str2, i, j - 1);
      }
   } else if (j == 0) {
      if (str1[i] == str2[j]) {
         return 1;
      } else {
         return process(str1, str2, i - 1, j);
      }
   } else {
      int p1 = process(str1, str2, i - 1, j);
      int p2 = process(str1, str2, i, j - 1);
      int p3 = str1[i] == str2[j] ? (1 + process(str1, str2, i - 1, j - 1)) : 0;
      return Math.max(p1, Math.max(p2, p3));
   }
}

dp动态规划版本

做一个N*M的一个矩阵，将所有情况都放在这个矩阵里面，依次拿好表中的值

public static int dp(String s1, String s2) {
    if (s1 == null || s2 == null || s1.length() == 0 || s2.length() == 0) {
			return 0;
		}
		char[] str1 = s1.toCharArray();
		char[] str2 = s2.toCharArray();
		int N = str1.length;
		int M = str2.length;
		int[][] dp = new int[N][M];
    	// 先填好第一张0位置
		dp[0][0] = str1[0] == str2[0] ? 1 : 0;
｝

填好第一行，第一列的位置

for (int j = 1; j < M; j++) {
   dp[0][j] = str1[0] == str2[j] ? 1 : dp[0][j - 1];
}
for (int i = 1; i < N; i++) {
   dp[i][0] = str1[i] == str2[0] ? 1 : dp[i - 1][0];
}

将递归的代码复制下来改成dp表就行，最后返回 N-1,M-1位置就好

for (int i = 1; i < N; i++) {
   for (int j = 1; j < M; j++) {
      int p1 = dp[i - 1][j];
      int p2 = dp[i][j - 1];
      int p3 = str1[i] == str2[j] ? (1 + dp[i - 1][j - 1]) : 0;
      dp[i][j] = Math.max(p1, Math.max(p2, p3));
   }
}
return dp[N - 1][M - 1];

这里的s1 [0…i ]和 s2 [0…j ] 其实就是一个对应的样本模型，它往往就讨论当前结尾应该如何组织可能性，这是一个经验。像这道题改成dp的时候它无非就是有3中情况：

dp[i - 1][j];
dp[i][j - 1];
dp[i - 1][j - 1];

相当于就是左边，上面，和左上角的位置然后取一个最大值。在写递归的时候也是就这些情况，只不过dp就是换成二维数组，写出尝试的暴力递归出来，其实改成动态规划也是差不多的。

一个样本做行一个样本做列的对应模型，你就以它结尾来组织可能性，实际上有些情况下是必须含有i和必须含有j，必须含有必须不含有j的四种情况，有些时候是有可能含有也有可能不含有，就是完全不考虑i和可能考虑,完全不考虑j和可能考虑,还有都考虑就这些可能性，总而言之可能性是怎么组织的以结尾，你i结尾我j结尾，以这样的结尾的这个东西来组织，你算的过程可以依赖你之前的东西的，所以这就是为什么要以结尾位置来组织可能性，因为结尾是分清楚了，你剩下的可能性都是算过的