Leetcode 1143. 最长公共子序列 记忆化搜索 优化 C++实现

Leetcode 1143. 最长公共子序列

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

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

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

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

算法1：递归搜索 + 保存计算结果 = 记忆化搜索

创建二维数组 memo 并赋初始值  -1 ，-1 代表这个元素没有被计算过。

进入函数 dfs ：如果两个字符相同，那么两个指针同时向后移动一个位置，进入下一层递归，计数器 +1 。

代码：

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int n = text1.length(),m = text2.length();
        vector<vector<int>> memo(n,vector<int>(m,-1));// -1代表没被选过
        auto dfs = [&](auto &&dfs,int i,int j) -> int{
            if(i < 0 || j < 0)  return 0;
            int &res = memo[i][j]; // 注意这里是引用
            if (res != -1) return res; // 之前计算过
            if (text1[i] == text2[j]) return res = dfs(dfs, i - 1, j - 1) + 1;
            return res = max(dfs(dfs, i - 1, j), dfs(dfs, i, j - 1));
        };
        return dfs(dfs, n - 1, m - 1);
    }
};

算法2：1:1 翻译成递推

创建二维数组 dp ，并赋初始值为 0 。dp [ i + 1 ] [ j +1 ] 表示 text1 的前 i 个字符与 text2 的前 j 个字符中的最长子序列长度。

当 text1 [ i ] == text2 [ j ] 时，dp [ i + 1 ] [ j +1 ] = dp [ i ] [ j ] + 1 ；

当 text1 [ i ]  != text2 [ j ] 时，dp [ i + 1 ] [ j +1 ] = max ( dp [ i ] [ j + 1 ] , dp [ i + 1] [ j ] ) 。

代码：

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int n = text1.length(), m = text2.length();
        vector<vector<int>> dp(n + 1, vector<int>(m + 1));
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                dp[i + 1][j + 1] = text1[i] == text2[j] ? dp[i][j] + 1 : max(dp[i][j + 1], dp[i + 1][j]);
        return dp[n][m];
    }
};

算法3：空间优化：两个数组（滚动数组）

通过算法2可以发现，二维数组 dp 的列空间只用到了相邻的两个位置，即 dp [ i + 1 ] [ ] 和 dp [ i ] [ ] ，所以我们可以把列空间优化，即把 dp 数组变为 2行 m+1 列 ，通过取余（ % ）操作，可以循环利用这两个空间。

最后 return dp [n % 2 ] [ m ] 的原因是要从 dp[ 0 ][ 0 ] 开始递归，所以 假设 n = 5 ，n % 2 为 1 ，我们就要 return dp [ 1 ] [ m ] 。

代码：

class Solution {
public:
    int longestCommonSubsequence(string s, string t) {
        int n = s.length(), m = t.length();
        vector<vector<int>> dp(2, vector<int>(m + 1));
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                dp[(i + 1) % 2][j + 1] = s[i] == t[j] ? dp[i % 2][j] + 1 : max(dp[i % 2][j + 1], dp[(i + 1) % 2][j]);
        return dp[n % 2][m];
    }
};

算法4：空间优化：一个数组

dp [ j + 1 ] 表示 text2 前 j 个元素与当前遍历到的 text1 的元素的最长子序列长度。

pre 表示先前 dp [ j + 1 ] 的状态，当 j 更新后，也就是此时的 dp [ j ] 的上一个值（没在本轮更新过的值）。这个操作保证了在遍历 text2 时，如果出现相同的字母，不会重复计算。例如，当前遍历到了 text1 的第一个 a ，刚好 text2 为 aca ，遍历 text2 过程中，遍历到第一个 a 时，个数 + 1，遍历到第二个 a 时，pre 等于这个位置之前的值，因为 a == a ，所以 dp = pre + 1 ，这样不会出现元素重复计算的情况，因为无论 text2 的这个元素是否与 text1 当前正遍历到的元素 相等，他们更新的 dp 值都相同，因为如果这两个元素不相等，如果前面的 dp 已经更新，那么此 dp 也会通过 max 操作更新。

代码中出现 j + 1 的原因是因为 text1 和 text2 中元素都是从下标 0 开始存储，而 dp 数组从下标 1 开始存储。

代码：

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int m = text2.length();
        vector<int> dp(m+1);
        for(char x : text1)
            for(int j = 0,pre = 0;j < m;j++){
                int temp = dp[j + 1];
                dp[j + 1] = x == text2[j] ? pre + 1 : max(dp[j],dp[j + 1]);
                pre = temp;
            }
        return dp[m];
    }
};