Leetcode——最长公共子序列 / 最长公共子串

Posted Yawn,

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Leetcode——最长公共子序列 / 最长公共子串相关的知识,希望对你有一定的参考价值。

1. 最长公共子序列

(1)DFS暴搜(超时)

class Solution{
    public static int longestCommonSubsequence(String text1, String text2) {
        char[] t1Chars = text1.toCharArray();
        char[] t2Chars = text2.toCharArray();
        return process(t1Chars, t2Chars, t1Chars.length, t2Chars.length);
    }

    //返回text1长度x,text2长度为y情况下的最长公共子序列长度
    private static int process(char[] t1Chars, char[] t2Chars, int x, int y) {
        if (x == 0 || y == 0) 
            return 0;
        return t1Chars[x-1] == t2Chars[y-1] 
        	   ? (process(t1Chars, t2Chars, x-1, y-1) + 1)
               : Math.max(process(t1Chars, t2Chars, x-1, y), process(t1Chars, t2Chars, x, y-1));
    }
}

(2)记忆化DFS

暴力递归慢就慢在对于一个位置值的重复求解,比如说process(3,3),在(4,4)的时候可能求一次,在(3,4)可能又求一次…等等,反正会被求到很多次

  • 记忆化:针对性的优化:使用缓存,将求过的值进行保存,下次直接使用
class Solution{

    public  int longestCommonSubsequence(String text1, String text2) {
        char[] t1Chars = text1.toCharArray();
        char[] t2Chars = text2.toCharArray();
        HashMap<String,Integer> cache = new HashMap<>();
        return process2(t1Chars, t2Chars, t1Chars.length, t2Chars.length, cache);
    }
    private  int process2(char[] t1Chars, char[] t2Chars, int x, int y, HashMap<String, Integer> cache) {
        //存储当前text1长度x,text2长度为y情况下的最长公共子序列长度,下次重复递归时可以直接使用
        String key = x + "_" + y;
        if (cache.containsKey(key)) 
            return cache.get(key);
        if (x == 0 || y == 0) {
            cache.put(key,0);
            return 0;
        }
        int result = t1Chars[x - 1] == t2Chars[y - 1] 
            ? (process2(t1Chars, t2Chars, x - 1, y - 1,cache) + 1)
            : Math.max(process2(t1Chars, t2Chars, x - 1, y,cache), process2(t1Chars, t2Chars, x, y - 1,cache));
        
        //存储当前计算的text1长度x,text2长度为y情况下的最长公共子序列长度
        cache.put(key,result);
        return result;
    }
}

(3)DP

  • 单个数组或者字符串要用动态规划时,可以把动态规划 dp[i] 定义为 nums[0:i] 中想要求的结果
  • 当两个数组或者字符串要用动态规划时,可以把动态规划定义成两维的 dp[i][j] ,其含义是在 A[0:i] 与 B[0:j] 之间匹配得到的想要的结果
  • 本题可以定义 dp[i][j] 表示 text1[0:i-1] 和 text2[0:j-1] 的最长公共子序列。
  • 注:text1[0:i-1] 表示的是 text1 的 第 0 个元素到第 i - 1 个元素,两端都包含)
    之所以 dp[i][j] 的定义不是 text1[0:i] 和 text2[0:j] ,是为了方便当 i = 0 或者 j = 0 的时候,dp[i][j]表示的为空字符串和另外一个字符串的匹配,这样 dp[i][j] 可以初始化为 0。
class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int len1 = text1.length();
        int len2 = text2.length();
        if (text1 == null || text2 == null || len1 < 1 || len2 < 1) 
            return 0;

        //定义 dp[i][j] 表示 text1[0:i-1] 和 text2[0:j-1] 的最长公共子序列。 所以需要 + 1
        //之所以 dp[i][j] 的定义不是 text1[0:i] 和 text2[0:j] ,是为了方便当 i = 0 或者 j = 0 的时候,
        //dp[i][j]表示的为空字符串和另外一个字符串的匹配,这样 dp[i][j] 可以初始化为 0。
        int[][] dp = new int[len1 + 1][len2 + 1];
        for (int i = 1; i <= len1; ++i) {
            for (int j = 1; j <= len2; ++j) {
                //由于当 i 和 j 取值为 0 的时候,dp[i][j] = 0,而 dp 数组本身初始化就是为 0,所以,直接让 i 和 j 从 1 开始遍历
                //遍历的结束应该是字符串的长度为 len(text1) 和 len(text2)。

                if (text1.charAt(i - 1) == text2.charAt(j - 1)) {
                //两个子字符串的最后一位相等,所以最长公共子序列又增加了 1
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                //两个子字符串的最后一位不相等,那么此时的状态 dp[i][j] 应该是 dp[i - 1][j] 和 dp[i][j - 1] 的最大值
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[len1][len2];
    }
}

2. 最长公共子串(最长重复数组)

假如有两个字符串,s1=“people"和s2=“eplm”,我们要求他俩最长的公共子串。我们一眼就能看出他们的最长公共子串是"pl”,长度是2。但如果字符串特别长的话就不容易那么观察了。

(1)暴力

public int getLCS(String s, String s2) {
        if (s == null || t == null) {
            return 0;
        }
        int l1 = s1.length();
        int l2 = s2.length();
        int res = 0;
        for (int i = 0; i < l1; i++) {
            for (int j = 0; j < l2; j++) {
                int m = i;
                int n = j;
                int len = 0;
                while (m < l1 && n < l2 && s1.charAt(m) == s2.charAt(n)) {
                    len++;
                    m++;
                    n++;
                }
                res = Math.max(res, len);
            }
        }
        return res;
    }

(2)DP

  • 用一个二维数组dp[i][j]表示 第一个字符串前 i 个字符 和 第二个字符串前 j 个字符 组成的最长公共字符串的长度。

  • 那么我们在计算dp[i][j]的时候,我们首先要判断s1.charAt(i)是否等于s2.charAt(j):

    • 如果不相等,说明当前字符无法构成公共子串,所以dp[i][j]=0。
    • 如果相等,说明可以构成公共子串,我们还要加上他们前一个字符构成的最长公共子串长度,也就是dp[i-1][j-1]。所以我们很容易找到递推公式
  • 递推公式为:

if(s1.charAt(i) == s2.charAr(j))
	dp[i][j] = dp[i-1][j-1] + 1;
else
	dp[i][j] = 0;

具体代码:

public static int maxLong(String str1, String str2) {
     if (str1 == null || str2 == null || str1.length() == 0 || str2.length() == 0)
         return 0;
     int max = 0;
     // +1是为了防止边界条件判断 和 减少初始化当 i 或 j 等于 0 时,初始化子串就是为0,初始化数组也是为0
     int[][] dp = new int[str1.length() + 1][str2.length() + 1];
     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))
                 dp[i][j] = dp[i - 1][j - 1] + 1;
            else
                dp[i][j] = 0;
            //最大值不一定出现在数组的最后一个位置,所以要用一个临时变量记录下来。
            max = Math.max(max, dp[i][j]);	
        }
    }
    return max;
}

(3)DP优化

public static int maxLong(String str1, String str2) {
    if (str1 == null || str2 == null || str1.length() == 0 || str2.length() == 0)
        return 0;
    int max = 0;
    int[] dp = new int[str2.length() + 1];
    for (int i = 1; i <= str1.length(); i++) {
    	//使用的倒序的方式,这是因为dp数组后面的值会依赖前面的值,而前面的值不依赖后面的值,所以后面的值先修改对前面的没影响,但前面的值修改会对后面的值有影响,所以这里要使用倒序的方式。
        for (int j = str2.length(); j >= 1; j--) {
            if (str1.charAt(i - 1) == str2.charAt(j - 1))
                dp[j] = dp[j - 1] + 1;
            else
                dp[j] = 0;
            max = Math.max(max, dp[j]);
        }
    }
    return max;
}

以上是关于Leetcode——最长公共子序列 / 最长公共子串的主要内容,如果未能解决你的问题,请参考以下文章

LeetCode1143. 最长公共子序列/300. 最长递增子序列//1713. 得到子序列的最少操作次数(好题!!!!!)

LeetCode 1143 最长公共子序列

《LeetCode之每日一题》:106.最长公共子序列

Leetcode 1143 最长公共子序列

LeetCode #1143 最长公共子序列

LeetCode 1143 最长公共子序列