LCS问题解答

首先是对于最长公共子序列的思考，我们作为个人是如何比较出来的，

s1，s2来说，我们一个个比对，无论是从s1开始找s2中第一个出现s1最先出现的字符，还是从s2中找s1中第一个出现的字符，之后两个指针依次往后遍历，找到最长的公共子串，但是有一个问题，当我们在寻找的时候，

String s1 = "aasdc";
String s2 = "cacsd";

当我们在找这两个字符串的最长子串的时候，s2的ac可以匹配到s1的ac，这时候如果中间有许多xx阻隔的话可能我们人工看的时候也出错，这个错误就是：当我们没有忽略到当前的麦穗，没有舍弃掉这个麦穗进行其他的尝试，就会出错，每当我碰到这种感觉的时候，我就知道“贪心会错过最优解”，这时候就需要进行动态规划来解决，因为动态规划是一种优化的递归，空间换时间的方式，将重复算的部分储存起来，从前往后或者从后往前进行遍历求解，那么确定好了动态规划之后就要开始思考边界问题，对于动态规划最重要的两部分就是边界（初始化）+状态转移方程，依次推导，

如果我们对于这个分解，从第一个问题开始，当我们s1或者s2只有一个字符是什么情况呢，我们用这个字符遍历s2/s1来找找看有没有相同的，公共子序列：有就是1，没有就是0，这就确定了一个字符的边界，

对于大问题就是如何慢慢的缩减规模，也就是如何从第一行，第一列慢慢的将整个表填完，表这时候肯定定义成n1 *n2：

1，n1指的是【1到n1】左右都闭合

1,n1 1,n2 ，分解成【1,n1-1 对1，n2】【 1，n1对1，n2-1 】【1，n1-1对1，n2-1】 【1，n1对1，n2 】 这时候【1，n1对1，n2】就不能用，因为你循环这个就会进入死循环，缩小规模只能从上面三个来想办法了，【1，n1-1对1，n2-1】比较好理解，n1 n2均-1，如果出现了n1 n2 的位置的字符一样，肯定就往后移动了，那么对于前两种，【1,n1-1 对1，n2】【 1，n1对1，n2-1 】，就可以理解成n1 n2位置的字符串不相同，找到这两种情况最大的填表，

来看看递归超时的情况：

public static int longestCommonSubsequence(String s1, String s2) {
        if (s1 == null || s2 == null || s1.length() == 0 || s2.length() == 0) {
            return 0;
        }
        return reverse(s1, s2, s1.length() - 1, s2.length() - 1);
    }

    public static int reverse(String s1, String s2, int i, int j) {
        if (i == -1 || j == -1) {
            return 0;
        }
        if (i == 0) {
            if (s1.charAt(0) == s2.charAt(j)) {
                return 1;
            } else {
                return reverse(s1, s2, 0, j - 1);
            }
        }
        if (j == 0) {
            if (s1.charAt(i) == s2.charAt(0)) {
                return 1;
            } else {
                return reverse(s1, s2, i - 1, 0);
            }
        }
        //对的上，同时往后移动
        if (s1.charAt(i) == s2.charAt(j)) {
            return 1 + reverse(s1, s2, i - 1, j - 1);
        }
        //对不上，找到s1后移一位和s2   s2后移一位和s1
        return Math.max(reverse(s1, s2, i, j - 1), reverse(s1, s2, i - 1, j));
    }

 再来看看dp的code

public static int dp(String s1, String s2) {
        if (s1 == null || s2 == null || s1.length() == 0 || s2.length() == 0) {
            return 0;
        }
        int n1 = s1.length(), n2 = s2.length();
        int[][] dp = new int[n1][n2];
        dp[0][0] = s1.charAt(0) == s2.charAt(0) ? 1 : 0;
        //列初始化      s1的0位置对比s2的所有位置找到第一个对的上的
        for (int i = 1; i < n1; i++) {
            dp[i][0] = s1.charAt(i) == s2.charAt(0) ? 1 : dp[i-1][0];
        }
        //行初始化       s2的0位置对比s1的所有位置找到第一个对的上的
        for (int i = 1; i < n2; i++) {
            dp[0][i] = s1.charAt(0) == s2.charAt(i) ? 1 : dp[0][i-1];
        }
        for (int i = 1; i < n1; i++) {
            for (int j = 1; j < n2; j++) {
                if (s1.charAt(i)==s2.charAt(j)){
                    dp[i][j] = dp[i-1][j-1]+1;
                }else {
                    dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1]);
                }
            }
        }
        //print打印
//        for (int i = 0; i < n1; i++) {
//            for (int j = 0; j < n2; j++) {
//                System.out.print(dp[i][j]);
//            }
//            System.out.println();
//        }
        return dp[n1-1][n2-1];
    }

 我在写的时候，因为不能确定我第一行，第一列到底填的对不对，我就喜欢用print来打印整张dp表和我草稿上的进行比较，看看到底哪里出错了

最主要就是如何一步步的分解，分解的边界到底是什么，不会的时候就打表来看看，例子一开始不要举的太复杂。