【Leetcode】1143. Longest Common Subsequence

题目地址：

https://leetcode.com/problems/longest-common-subsequence/

经典的最长公共子序列问题。若s1.length=n，s2.length=m，应用动态规划可以达到$O(nm)$。设$f(i,j)$代表$s1[0,1,...,i]$和$s2[0,1,...,j]$的最长公共子序列的长度（子序列和子串是不一样的，子序列不要求连续而子串要求连续）。可以按照这个最长公共子序列是否包含$s1[i]$和$s2[j]$来分类讨论，那么有四种情况（这四种情况包含了所有情况，但并不互斥。由于这里是求最长值，所以不互斥并没有影响）：
1、这个最长公共子序列不包含$s1[i]$和$s2[j]$；
2、这个最长公共子序列包含$s1[i]$，但不包含$s2[j]$；
3、这个最长公共子序列不包含$s1[i]$，但包含$s2[j]$；
4、这个最长公共子序列既包含$s1[i]$，又包含$s2[0,1,...,j]$；
很显然$f[i][j]$是这四种情况的最大值（容易看出来这四种情况并不是互斥的，比如第一种情况就被包含在了第二和三种情况中了，但这不影响我们求最大值）。其中，第一种情况就是$f[i-1][j-1]$，第二三种情况分别被包含在$f[i][j-1]$和$f[i-1][j]$的情况中（意思是如果有满足第二种的最长公共子序列，那么其长度必然等于$f[i][j-1]$），第四种情况取决于$s1[i]$和$s2[j]$是否相等。如果相等，那么$f[i][j]=f[i-1][j-1]+1$，否则的话，$f[i][j]$就等于前三种情况的最大值。不管怎样，要求$f[i][j]$，本质上就是求$f[i][j-1]$，$f[i-1][j]$和$f[i-1][j-1]+1$的最大值。这三个都是规模更小的问题，于是问题我们已经解决了。代码如下：

public class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        if (text1 == null || text2 == null || text1.length() == 0 || text2.length() == 0) {
            return 0;
        }
        // dp[i][j]是text1[0,...,i]和text2[0,...,j]的最长公共子序列的长度
        int[][] dp = new int[text1.length() + 1][text2.length() + 1];
    
        for (int i = 1; i <= text1.length(); i++) {
            for (int j = 1; j <= text2.length(); j++) {
                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                if (text1.charAt(i - 1) == text2.charAt(j - 1)) {
                    dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - 1] + 1);
                }
            }
        }
        
        return dp[text1.length()][text2.length()];
    }
}

时空复杂度$O(mn)$。

接下来考虑空间优化。由于$f[i][j]$只取决于当前行与上一行的信息，所以我们可以考虑按照行优化（也可以按照列优化，因为它也可以看成只取决于当前列与上一列的信息）。为了节省空间，我们可以开一个数组，其长度等于两个字符串的较短的那个长度。接下来我们考虑这个数组是开一维还是两维。开两维显然可以解决问题，我们只需要用滚动数组就可以了。但是否一维也可以解决问题呢？答案是，不可以。原因是，$f[i][j]$既依赖$f[i][j-1]$又依赖$f[i-1][j-1]$，如果我们按照从左向右更新，那么等到要更新$f[i][j]$的时候，$f[i-1][j-1]$已经被覆盖了，这样没法处理$f[i-1][j-1]$的情况；如果从右向左更新，那么等到要更新$f[i][j]$的时候，$f[i][j-1]$还没更新到，这个值是未知的，这样没法处理$f[i][j-1]$的情况（其实本质并不是从左向右还是从右向左，而是$f[i-1][j-1]$和$f[i-1][j]$到底先更新谁。此处可以看到，先更新谁都解决不了问题）。所以在这个题目里，必须开两维数组，然后用滚动的方式更新。代码如下

public class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        if (text1 == null || text2 == null || text1.length() == 0 || text2.length() == 0) {
            return 0;
        }
        // 接下来置text1是长度较小的那个字符串
        if (text1.length() > text2.length()) {
            String tmp = text1;
            text1 = text2;
            text2 = tmp;
        }
        
        int[][] dp = new int[2][text1.length() + 1];
        int index = 0;
        for (int j = 1; j <= text2.length(); j++) {
            for (int i = 1; i <= text1.length(); i++) {
                dp[index][i] = Math.max(dp[index][i - 1], dp[index ^ 1][i]);
                if (text1.charAt(i - 1) == text2.charAt(j - 1)) {
                    dp[index][i] = Math.max(dp[index][i], dp[index ^ 1][i - 1] + 1);
                }
            }
            index ^= 1;
        }
        
        return dp[index ^ 1][text1.length()];
    }
}

时间复杂度不变，空间$O(\min \{m,n\})$。