LeetCode 1143 最长公共子序列

题目

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。

若这两个字符串没有公共子序列，则返回 0。

示例 1:

输入：text1 = "abcde", text2 = "ace" 
输出：3  
解释：最长公共子序列是 "ace"，它的长度为 3。
示例 2:

输入：text1 = "abc", text2 = "abc"
输出：3
解释：最长公共子序列是 "abc"，它的长度为 3。
示例 3:

输入：text1 = "abc", text2 = "def"
输出：0
解释：两个字符串没有公共子序列，返回 0。
 

提示:

1 <= text1.length <= 1000
1 <= text2.length <= 1000
输入的字符串只含有小写英文字符。

思路 一 暴力

就是暴力递归，求出text1的所有子序列，然后和text2比较，得出最长的子序列。需要指数级的时间复杂度。求子序列的递归类似于前面的括号生成 的递归

思路二 动态规划

怎么使用动态规划

• 找到重复的子问题，把复杂的问题转换为简单的子问题
• 需要定义它的状态空间，从俩个字符串，变成二维的数组空间
• 求它的状态转移方程，并能合并子问题的解
• 得到递推公式（状态转移方程），然后自底向上进行递推，从初始值进行，得到最后的解

这里的动态规划步骤

• 建立二维dp数组
  
• dp[i][j]数组，存储的是字符串数组t1[i-1],t2[j-1]的最长子序列
• 当t1[i-1]==t2[j-1],说明这两个字符是公共的字符，只要考察其子问题，dp[i-1][j-1]的长度在此基础上+1
• 当不等于的话，不是公共的字符，就在dp[i][j-1] 和dp[i-1][j]上取最大值。

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        if (text1 == null || text2 == null || text1.length() == 0 || text2.length() == 0) {
            return 0;
        }
        char[] t1 = text1.toCharArray();
        char[] t2 = text2.toCharArray();
        int m = t1.length;
        int n = t2.length;
        int[][] dp = new int[m + 1][n + 1];  //dp数组的第0行和列都是0，可定义数组的初始值
        for (int i = 1; i < m + 1; i++) { //这里面的俩个for循环的方程，把dp数组的初始值也定义了
            for (int j = 1; j < n + 1; j++) {
                if (t1[i-1] == t2[j-1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[m][n];
    }
}

复杂度分析

时间复杂度：O(mn)
空间复杂度：O(mn)

优化空间

来自作者：a-fei-8

用一维数组的dp

• last:表示是当前dp[j]，原来是(dp[i][j])左上角的数，相当于dp[i-1][j-1],初始化的时候为0
• tmp:表示是当前dp[j]，原来是(dp[i][j])正上方的数，相当于dp[i- 1][j]
• dp[j-1]:表示是当前dp[j]，原来是(dp[i][j])左边的数，相当于dp[i][j-1]
• 每一轮结束后，last的值都向前滚动一个，变成正上方的数，也就是tmp

public int longestCommonSubsequence3rd(String text1, String text2) {
    if (text1 == null || text2 == null ||
        text1.length() == 0 || text2.length() == 0) return 0;
        int m = text1.length(), n = text2.length();
        int[] dp = new int[n + 1];
        int tmp = 0;
        for (int i = 1; i <= m; i++) {
            int last = 0;
            for (int j = 1; j <= n; j++) {
                tmp = dp[j];  //这里的dp[j]是没改变前的，相当于上一组的，相当于正上方
                if (text1.charAt(i - 1) == text2.charAt(j - 1)) dp[j] = last + 1;
                else dp[j] = Math.max(tmp, dp[j - 1]); //这里dp[j-1]是改变的了，相当与左边
                last = tmp;  //这里就是上一组的dp[j]的正上方，然后下一次的dp[j+1]，就是左上方
            }
        }
        return dp[n];
    }

空间复杂度：O(N)