力扣第1143题 最长公共子序列 c++ 动态规划 附Java代码 注释版

题目

1143. 最长公共子序列

中等

相关标签

字符串   动态规划

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

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

• 例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。

两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

示例 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, text2.length <= 1000
• text1 和 text2 仅由小写英文字符组成。

思路和解题方法

• vector> dp(text1.size() + 1, vector(text2.size() + 1, 0));：创建一个二维数组dp，用于记录最长公共子序列的长度。其中，第一维表示text1字符串的长度加1，第二维表示text2字符串的长度加1，初始值为0。
• for (int i = 1; i <= text1.size(); i++)：从第二个字符开始遍历text1字符串，因为需要与前一个字符比较。
• for (int j = 1; j <= text2.size(); j++)：从第二个字符开始遍历text2字符串，因为需要与前一个字符比较。
• if (text1[i - 1] == text2[j - 1])：如果当前字符相等，表示在最长公共子序列中，更新最长公共子序列的长度。此处的i-1和j-1是因为dp数组从下标1开始计算，而text1和text2字符串从下标0开始计算。
• dp[i][j] = dp[i - 1][j - 1] + 1;：如果当前字符相等，在最长公共子序列的基础上再加1，更新最长公共子序列的长度。
• else：如果当前字符不相等。
• dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);：取前一行或前一列的最大值作为最长公共子序列的长度。
• return dp[text1.size()][text2.size()];：返回最长公共子序列的长度。

复杂度

        时间复杂度:

                O(m*n)

时间复杂度是O(m*n)，其中m和n分别是字符串text1和text2的长度。因为需要遍历两个字符串，每个字符需要比较一次。

        空间复杂度

                O(m*n)

空间复杂度是O(m*n)，因为使用了一个二维数组dp来存储最长公共子序列的长度。其中，dp的大小是(text1.size() + 1) * (text2.size() + 1)。

c++ 代码

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        // 创建一个二维数组dp，用于记录最长公共子序列的长度
        vector> dp(text1.size() + 1, vector(text2.size() + 1, 0));
        
        for (int i = 1; i <= text1.size(); i++) { // 遍历text1字符串
            for (int j = 1; j <= text2.size(); j++) { // 遍历text2字符串
                if (text1[i - 1] == text2[j - 1]) { // 如果当前字符相等，表示在最长公共子序列中
                    dp[i][j] = dp[i - 1][j - 1] + 1; // 更新最长公共子序列的长度
                }
                else {
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]); // 如果当前字符不相等，取前一行或前一列的最大值作为最长公共子序列的长度
                }
            }
        }
        
        return dp[text1.size()][text2.size()]; // 返回最长公共子序列的长度
    }
};

Java代码

• 定义一个函数longestCommonSubsequence，接收两个字符串text1和text2，返回一个int类型的值。
• 创建一个大小为(text1.length()+1)*(text2.length()+1)的二维数组dp，用于存储最长公共子序列的长度，默认初值为0。
• 遍历text1和text2，从第一个字符到最后一个字符。在循环中，获取text1和text2中的当前字符（char1和char2），并根据当前字符的相等与否来更新dp[i][j]的值。如果char1等于char2，则可以将这个字符加入到最长公共子序列中，更新dp[i][j]的值为dp[i-1][j-1] + 1。如果char1不等于char2，则最长公共子序列的长度取决于dp[i-1][j]和dp[i][j-1]的较大值。
• 最后，返回dp[text1.length()][text2.length()]，即最长公共子序列的长度。

class Solution {
    public int longestCommonSubsequence(String text1, String text2) { // 定义一个函数，接收两个字符串text1和text2，返回一个int类型的值
        int[][] dp = new int[text1.length() + 1][text2.length() + 1]; // 创建一个大小为(text1.length()+1)*(text2.length()+1)的二维数组dp，用于存储最长公共子序列的长度，默认初值为0
        
        for (int i = 1; i <= text1.length(); i++) { // 遍历text1，从第一个字符到最后一个字符
            char char1 = text1.charAt(i - 1); // 获取text1中第i个字符
            for (int j = 1; j <= text2.length(); j++) { // 遍历text2，从第一个字符到最后一个字符
                char char2 = text2.charAt(j - 1); // 获取text2中第j个字符
                if (char1 == char2) { // 如果text1中第i个字符等于text2中第j个字符，则可以将这个字符加入到最长公共子序列中
                    dp[i][j] = dp[i - 1][j - 1] + 1; // 更新dp[i][j]的值，dp[i][j]表示以text1的前i个字符和text2的前j个字符结尾的最长公共子序列的长度
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]); // 如果text1中第i个字符不等于text2中第j个字符，则最长公共子序列的长度取决于dp[i-1][j]和dp[i][j-1]的较大值
                }
            }
        }
        
        return dp[text1.length()][text2.length()]; // 返回最长公共子序列的长度
    }
}

觉得有用的话可以点点赞，支持一下。

如果愿意的话关注一下。会对你有更多的帮助。

每天都会不定时更新哦  >人<  。