华为OJ之最长公共子序列

题目描述：

对于两个给定的字符串，给出他们的最长公共子序列。

题目分析：

1，在之前的博文(http://www.cnblogs.com/yonguo123/p/6711360.html)中我们讨论了最长公共子串的问题，当时也指出最长公共子串其实就是最长公共子序列的一种特殊情况，那么今天我们就来一起研究一下最长公共子序列的求解；

2，最长公共子序列的定义这里不再赘述，和之前的最长公共子串一样，我们这次仍然采用动态规划和回溯的思想来解决；

3，我们假设输入为str1, str2, 首先来通过动态规划获取最大最序列的长度：

　  3-1，构建一个二维数组tempMatrix，维度为(str1.length + 1), (str2.length + 1);

3-2，temp[i][j]的含义：str1.subString(0, i)和str2.subString(0, j)的最长公共子序列(注意理解这个数组的含义)的长度;

3-3，显然temp[i][j] == 0, 当i == 0 || j == 0;

3-4，否则，当 str1.charAt(i - 1) == str2.charAt(j - 1)时，temp[i][j] = temp[i - 1][j - 1] + 1, 否则temp[i][j] == max{temp[i, j - 1], temp[i - 1, j]}(具体原因大家自己思考一下，可以从新加入的两个尾字符是否会出现在新的LCS中来思考);

4，已经构建好了tempMatix矩阵，实际上tempMatrix[str1.length][str2.length]就是LCS的长度了，而且tempMatrix也保存了必要的回溯信息，下面我们继续构建一个String[][] flagMatrix = new String[str1.length][str2.length], 规则如下：

　　

　　可能会有同学对这个左上，上，左的取值有疑问，请看下面这张回溯图：

　　

　　实际上回溯时具体的方向与我们对于坐标的选取是有关系的，所以大家在写代码之前，应该先把坐标方向规定好。之后的工作就是利用flagMatrix来逐步回溯，详细的实现细节见代码。

5，如果还有其它更好的想法，欢迎大家与我交流^-^

具体代码(Java实现)：

 import java.util.Scanner;

 public class LCSequence {
     public static void main(String[] args) {
         String[] paras = getInput();
         System.out.println(getLongestSubsequence(paras[0], paras[1]));
     }

     public static String[] getInput() {
         Scanner reader = new Scanner(System.in);
         String[] paras = new String[2];
         paras[0] = reader.nextLine();
         paras[1] = reader.nextLine();
         reader.close();
         return paras;
     }

     public static String[][] getGenerationMatirx(String str1, String str2) {
         int[][] temp = new int[str1.length() + 1][str2.length() + 1];
         String[][] flag = new String[str1.length() + 1][str2.length() + 1];
         for (int i = 0; i <= str1.length(); i ++) {
             temp[i][0] = 0;
         }
         for (int i = 0; i <= str2.length(); i ++) {
             temp[0][i] = 0;
         }
         //迭代获取最长公共子序列的生成矩阵
         for (int i = 1; i <= str1.length(); i ++) {
             for (int j = 1; j <= str2.length(); j ++) {
                 if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
                     temp[i][j] = temp[i - 1][j - 1] + 1;
                     flag[i][j] = "left_up";
                 } else {
                     if (temp[i - 1][j] >= temp[i][j - 1]) {
                         temp[i][j] = temp[i - 1][j];
                         flag[i][j] = "up";
                     } else {
                         temp[i][j] = temp[i][j - 1];
                         flag[i][j] = "left";
                     }
                 }
             }
         }
         return flag;
     }
     public static String getLongestSubsequence(String str1, String str2) {
         String[][] flagMatrix = getGenerationMatirx(str1, str2);
         String tempString = "";
         for (int i = str1.length(), j = str2.length(); i > 0 && j > 0;) {
                 if (flagMatrix[i][j].equals("left_up")) {
                     tempString += str1.charAt(i - 1);
                     i --;
                     j --;
                 } else if (flagMatrix[i][j].equals("left")) {
                     j --;
                 } else {
                     i --;
                 }
         }
         return new StringBuffer(tempString).reverse().toString();
     }

 }

运行结果：

　   

　　这里需要注意一点，因为LCS可能不止一个，所以对于flagMatrix的赋值其实不止一种情况，代码34行中大于或者大于等于都可以，但是可能会输出不同的结果。