最长公共字串和最长公共子序列

动态规划概念：

Programming   -  在这里指用数学方法来根据子问题求解当前问题（通俗理解就是找到递推公式）

Dynamic     -  指缓存上一步结果，根据上一步结果计算当前结果

简单理解：找出递推公式，将当前问题分解成子问题，分阶段进行求解。

                  求解过程中缓存子问题的解，避免重复计算。  

例题1：最长公共字串

求两个字符串的最长公共字串，比如有两个字符串，str1 = "itheima" , str2 = "thema",求出这两个字符串最长公共部分的长度。

分析：

我们可以用动态规划的思想，先创建一个二维表格，可以用str1中的每一个字符代表二维表格的每一列（column），用str2中的每一个字符代表二维表格的每一行（row）。并从中看看能不能找出一个递推公式。当在比对中遇到相同字符时，我们需要知道上一次比对的字符是否也相同，也就是前一行，前一列的元素，如果相同，则需在上一次的基础上 + 1，不同则赋值为0。

我们可以得到递推如下递推公式：

这里需要注意：我们要对第一行和第一列的元素进行特殊处理（比对相同则直接赋值为1）。

代码实现：

import java.util.Arrays;

/**
 * 最长公共字串
 */
public class LCSubstring {

    public static void main(String[] args) {
        System.out.println(lcs("itheima", "thema"));
    }

    static void print(int[][] dp, String a, String b) {
        System.out.println("-".repeat(23));
        Object[] array = a.chars().mapToObj(i -> String.valueOf((char) i)).toArray();
        System.out.printf("  "+"%2s ".repeat(a.length()) + "%n", array);
        for (int i = 0; i < b.length(); i++) {
            int[] d = dp[i];
            array = Arrays.stream(d).boxed().toArray();
            System.out.printf(b.charAt(i) + " " + "%2d ".repeat(d.length) + "%n", array);
        }
    }

    /*
            i   t   h   e   i   m   a
         t  0   1   0   0   0   0   0
         h  0   0   2   0   0   0   0
         e  0   0   0   3   0   0   0
         m  0   0   0   0   0   1   0
         a  0   0   0   0   0   0   2

         if(相同字符){
            dp[i][j] = dp[i - 1][j - 1] + 1;
         }else{
            dp[i][j] = 0;
         }
     */

    public static int lcs(String a, String b){
        int[][] dp = new int[b.length()][a.length()];
        int max = 0;
        for (int i = 0; i < b.length(); i++) {
            for (int j = 0; j < a.length(); j++) {
                if(a.charAt(j) == b.charAt(i)){
                    if(i == 0 || j == 0){
                        dp[i][j] = 1;
                    }else{
                        dp[i][j] = dp[i - 1][j - 1] + 1;
                    }
                    max = Math.max(max, dp[i][j]);
                }
            }
        }
        print(dp, a, b);
        return max;
    }
}

接下来我们来看另一道例题

---

例题2：最长公共子序列

分析：

公共子串要求字符连续，而子序列不要求字符连续。但是子序列顺序要保证和原字符串顺序一致。先创建一个二维表格，第一行和第一列全部填0，这样就不用进行特殊处理了。

我们仍然可以得到以下递推式：

代码实现：

import java.util.Arrays;

/**
 * 最长公共子序列
 */
public class LCSubsequence {

    /*
     *   if(相同字符){
     *       dp[i][j] = dp[i - 1][j - 1] + 1;
     *   }else{
     *       dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
     *   }
     *
     * */
    public int longestCommonSubsequence(String text1, String text2) {
        int m = text1.length();
        int n = text2.length();
        int[][] dp = new int[m + 1][n + 1];  //第一行第一列空出来不做处理
        for (int i = 1; i < m + 1; i++) {
            for (int j = 1; j < n + 1; j++) {
                if(text1.charAt(i - 1) == text2.charAt(j - 1)){ //二维表格索引从1开始，但字符串索引要从0开始
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }else{
                    dp[i][j] = Integer.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        print(dp, text2, text1);
        return dp[m][n];
    }


    static void print(int[][] dp, String a, String b) {
        System.out.println("-".repeat(23));
        Object[] array = a.chars().mapToObj(i -> String.valueOf((char) i)).toArray();
        System.out.printf("     " + "%2s ".repeat(a.length()) + "%n", array);
        System.out.printf("     " + "%2s ".repeat(a.length()) + "%n", a.chars().mapToObj(i -> "0").toArray());
        for (int i = 0; i < b.length(); i++) {
            int[] d = dp[i + 1];
            array = Arrays.stream(d).boxed().toArray();
            System.out.printf(b.charAt(i) + " " + "%2d ".repeat(d.length) + "%n", array);
        }
    }

    public static void main(String[] args) {
        LCSubsequence code = new LCSubsequence();
        System.out.println(code.longestCommonSubsequence("abxyz", "abcxyz"));
        //System.out.println(code.longestCommonSubsequence("ba", "yby"));
    }
}