最长公共子序列的两种写法：dp数组和备忘录

先看题

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

示例 1:

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

示例 2:

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

示例 3:

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

这类题有两种动态规划法的解法

第一种解法：备忘录memo

就是用两个指针i和j分别遍历两个字符串。

如果两个字符串对应的i和j的字符相等，就同时加一向后移；

不相等时，选择i+1或j+1中的较大值。

直到i和j中的有一个遍历结束字符串，一个遍历完后,因为base case 为0的原因，所以会继续遍历另一个字符串，知道结束

// 备忘录，消除重叠子问题
int[][] memo;

/* 主函数 */
int longestCommonSubsequence(String s1, String s2) {
    int m = s1.length(), n = s2.length();
    // 备忘录值为 -1 代表未曾计算
    memo = new int[m][n];
    for (int[] row : memo) 
        Arrays.fill(row, -1);
    // 计算 s1[0..] 和 s2[0..] 的 lcs 长度
    return dp(s1, 0, s2, 0);
}

// 定义：计算 s1[i..] 和 s2[j..] 的最长公共子序列长度
int dp(String s1, int i, String s2, int j) {
    // base case
    if (i == s1.length() || j == s2.length()) {
        return 0;
    }
    // 如果之前计算过，则直接返回备忘录中的答案
    if (memo[i][j] != -1) {
        return memo[i][j];
    }
    // 根据 s1[i] 和 s2[j] 的情况做选择
    if (s1.charAt(i) == s2.charAt(j)) {
        // s1[i] 和 s2[j] 必然在 lcs 中
        memo[i][j] = 1 + dp(s1, i + 1, s2, j + 1);
    } else {
        // s1[i] 和 s2[j] 至少有一个不在 lcs 中
        memo[i][j] = Math.max(
            dp(s1, i + 1, s2, j),
            dp(s1, i, s2, j + 1)
        );
    }
    return memo[i][j];
}

第二种解法：dp数组

动态规划思路：确定dp数组含义——>定义base case ——>找状态转移方程

第一步 确定dp数组

对于两个字符串的动态规划问题，套路是通用的。

比如说对于字符串 s1 和 s2，它们的长度分别是 m、n，一般来说都要构造一个这样的 DP table：int[][] dp = new int[m+1] [n+1]。

这里为什么要加1，原因是你可以不加1，但是不加1你就会用其它限制条件来确保这个index是有效的，而当你加1之后你就不需要去判断只是让索引为0的行和列表示空串。

比如m和n分别是5和3， 因为数组下标是从0开始的，想要获得[5] [3]下标的数组,就要定义一个6 * 4 的二维数组，也就是new int[m+1] [n+1]。一个是数组坐标 一个是数组长度

就像这张图一样

第二步 定义base case

专门让索引为0的行和列表示空串，dp[0][...] 和 dp[...][0] 都应该初始化为0，这就是base case。

第三步 找状态转移方程

对两个字符串，定义两个指针遍历i和j

遍历 text1 长度为 m，定义指针 i，从 0～m。固定 i 指针（i == 1）位置，接下来开始遍历 text2 长度为 n，定义指针 j，从 0~n。

• 第一次遍历 i = 1, j = 1，两个a相同所以 dp[1] [1] = 1
• 第二次遍历 i = 1, j = 2，a与c不等，也不能是0，这里需转换成 a 与 ac 最长子序列，这里需要把之前的关系传递过来，所以dp[1] [2] = 1
• 第三次遍历 i = 1, j = 3，a与e不相同，把之前的关系传递过来，所以dp[1] [3] = 1
  text2：ace 已经走完来第一轮，接下来text1：abcde 走到来b字符。
• 第四次遍历 i = 2, j = 1，就是需要比较ab与a的最长子串，把之前的关系传递过来，所以dp[2] [1] = 1

当两个字符串的字符相同时候，需要考虑不包含当前字符串的子序列长度，再加上1,也就是找它们前面各退一格的值加1即可：dp[i+1][j+1] = dp[i][j] + 1;；

不同时，选择左边和上边的较大的值,也就是要取它的「要么是text1往前退一格，要么是text2往前退一格，两个的最大值」dp[i + 1] [j + 1] = Math.max(dp[i+1] [j], dp[i] [j+1]);

class Solution {
  public int longestCommonSubsequence(String s1, String s2) {
    int m = s1.length(), n = s2.length();
    int[][] dp = new int[m + 1][n + 1];
    
    for (int i = 0; i < m; i++) {
      for (int j = 0; j < n; j++) {
        char c1 = s1.charAt(i);
        char c2 = s2.charAt(j);
        if (c1 == c2) {
          dp[i + 1][j + 1] = dp[i][j] + 1;
        } else {
          dp[i + 1][j + 1] = Math.max(dp[i + 1][j], dp[i][j + 1]);
        }
      }
    }
    return dp[m][n];
  }
}