最长公共子串问题

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

str1="1AB2345CD" str2="12345EF" 返回"2345"

1. 定义状态数组

dp[i][j]表示是：把str1[i]和str2[j]当作公共子串最后一个字符的情况下，公共子串最长能有多长。

注意：此时的str1[i]与str2[j]就是此时比较的子串而不是要去拆分的子串。
例如str1 = "A1234B" str2="CD1234"，dp[3][4]即: str1[3] = "A12E"与str2[4]="CD12F"。由于最后一个字符不同所以无法匹配，即dp[3][4]=0

2.初始条件

第一行和第一列为初始条件：分别用首字符去匹配每个行和列的每个字符，相同的位置为1，不同的位置为0.

3.转移方程

通过作图我们可以知道如果末尾不同的情况下该状态为0，相同的情况下当前状态为上个对角线的状态+1；

4.计算顺序

从状态方程可知，计算下个状态依赖上个状态，所以是从小到大。

/**
 * 最长公共子串问题与公共子序列的区别：子序列可以不是连续的，
 * 但是子串必须是连续的;
 * 将动态数组构建过程中的char数组当做要去匹配的子串【最后一个字符不同就是0】
 */
public class Solution9 {
    public static int[][] getdp(char[] str1, char[] str2){
        // dp[i][j]表示的是在str1[0...i-1]和str2[0...j-1]之间的公共子串个数
        int[][] dp = new int[str1.length][str2.length];

        // 初始化条件
        dp[0][0] = str1[0] == str2[0] ? 1 : 0;
        // 第一行的计算
        for (int i = 1; i < str2.length; i ++){
            dp[0][i] =  str1[0] == str2[i] ? 1 : 0;
        }
        // 第一列的计算
        for (int j = 1; j < str1.length; j ++){
            dp[j][0] = str1[j] == str2[0] ? 1 : 0;
        }

        // 转移方程和计算顺序
        for (int i = 1; i < str1.length; i ++){
            for (int j = 1; j < str2.length; j ++){
                if (str1[i] == str2[j]){
                    dp[i][j] = dp[i-1][j-1] + 1;
                }
            }
        }
        return dp;
    }

    public static String lcst1(String arr1, String arr2){
        if (arr1 == null || arr2 == null || arr1.equals("") || arr2.equals("")){
            return "";
        }
        char[] str1 = arr1.toCharArray();
        char[] str2 = arr2.toCharArray();
        int[][] dp = getdp(str1, str2);
        int end = 0;
        int max = 0;
        for(int i = 0; i < str1.length; i ++){
            for (int j = 0; j < str2.length; j ++){
                if (dp[i][j] > max){
                    // 获取当前最大的dp以及其子串开始的位置
                    end = i;
                    max = dp[i][j];
                }
            }
        }
        return arr1.substring(end - max + 1, end + 1);
    }

    public static void main(String[] args) {
        // substring 包括前面不包括后面
        System.out.println(lcst1("1AB2345CD", "12345EF"));

    }
}

优化

在状态更新的过程中，我们只用到了dp[i-1][j-1]的值，所以可以只使用一个变量来记录dp[i-1][j-1]的值，在计算的过程中一直是按照斜线的方向计算的。

在计算之前生成整形变量len，len表示上方位置的值，初始时len = 0。如果str[i]==str2[j]，那么位置(i,j)的值为len +1，如果str[i]!=str2[j]，那么位置(i,j)的值为0，计算后将len更新成位置(i,j)的值，然后计算下一个位置。

public static String lcst2(String str1, String str2){
        if (str1 == null || str2 == null || str1.equals("") || str2.equals("")){
            return "";
        }
        char[] chs1 = str1.toCharArray();
        char[] chs2 = str2.toCharArray();
        int row = 0; // 斜线开始位置的行
        int col = chs2.length - 1; // 斜线开始位置的列
        int max = 0; // 记录最大长度
        int end = 0; // 最大长度更新时， 记录子串的结尾位置

        while(row < chs1.length){
            int i = row;
            int j = col;
            int len = 0;

            // 从(i, j)开始向右下方遍历
            while(i < chs1.length && j < chs2.length){
                // 如果当前位置的值不相等--置0
                if (chs1[i] != chs2[j]){
                    len = 0;
                } else {
                    len ++ ;
                }

                // 记录最大值，以及结束字符的位置
                if (len > max){
                    end = i;
                    max = len ;
                }
                i ++;
                j ++;
            }

            if (col > 0){
                // 斜线开始位置的列先向左移动
                col --;
            } else {
                // 列移动到最左之后，行向下移动
                row ++;
            }
        }
        return str1.substring(end - max + 1, end +1);
    }