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];
}
};
