题解 | #公共子串计算#

本题与 LC 718. 最长重复子数组类似。
解法可见 C++ 数据结构与算法（十三）（动态规划 -- 打家劫舍、股票问题、子序列问题）。

1. 动态规划

1. dp[i][j] 表示以 s1[i-1]、s2[j-1]为结尾（一定包括这两个字符）的字符串的公共子串长度（不一定是最大）；
2. 初始化为0；
3. 如果s1[i-1] == s2[j-1]，那么 dp[i][j] = dp[i-1][j-1] + 1;，并比较更新最大长度；
否则，字符串结尾不相等，即公共长度为0.
4. 从前往后遍历。

• 时间复杂度：，n 为A长度，m为B长度
• 空间复杂度：

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

int main(){
    string s1, s2;
    while(cin >> s1 >> s2){
        int n = s1.length(), m = s2.length(), ans = 0;
        vector<vector<int>> dp(n+1, vector<int>(m+1, 0));
        for(int i = 1; i <= n; ++i){
            for(int j = 1; j <= m; ++j){
                if(s1[i-1] == s2[j-1]){                // 所选字符串结尾相等
                    dp[i][j] = dp[i-1][j-1] + 1;    // 上一串长度 + 1
                    ans = max(ans, dp[i][j]);
                }                                    // s1[i-1] != s2[j-1] 即结尾不相同，长度为0
            }
        }
        cout << ans << endl;
    }
    return 0;
}

• 一维滚动数组优化空间复杂度 O(n)

dp[i][j] 都是由dp[i - 1][j - 1]推出。那么压缩为一维数组，也就是dp[j]都是由dp[j - 1]推出。

也就是相当于可以把上一层dp[i - 1][j]拷贝到下一层dp[i][j]来继续用。

此时遍历B数组的时候，就要从后向前遍历，这样避免重复覆盖，且长度为 0 时要注意赋值。

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

int main(){
    string s1, s2;
    while(cin >> s1 >> s2){
        int n = s1.length(), m = s2.length(), ans = 0;
        vector<int> dp(m+1, 0);
        for(int i = 1; i <= n; ++i){
            for(int j = m; j >= 1; --j){
                if(s1[i-1] == s2[j-1]){
                    dp[j] = dp[j-1] + 1;    // 相等
                    ans = max(ans, dp[j]);
                }else{
                    dp[j] = 0;                // 不相等
                }
            }
        }
        cout << ans << endl;
    }
    return 0;
}

2. 滑动窗口

通过滑动字符串来遍历所有字符串重叠的情况，然后在重叠部分找最大公共子串的长度。

如图可知，枚举 字符串 所有的重叠（对齐）方式主要分为三步（s1长度更小）：
（1）s1 尾部开始与 s2 重叠，直到 s1 完全被覆盖；
（2）s1 头部与 s2 头部开始错位，直到 s1 尾部 与 s2 尾部重叠；
（3）s1 尾部超过 s2 尾部，直到不再重叠。

每次滑动操作需要更新两个字符串的重叠起始下标和结束下标。

• 时间复杂度：
• 空间复杂度：

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

int getLen(string s1, string s2, int a1, int b1, int a2, int b2){   // 找到s1[a1, b1]和s2[a2,b2]的最大公共子串长度
    int n = b1 - a1 + 1;
    int pre = 0, ans = 0;
    for(int i = 0; i < n; ++i){
        if(s1[a1 + i] == s2[a2 + i]){
            ans = max(ans, pre + 1);
            ++pre;
        }else{
            pre = 0;
        }
    }
    return ans;
}

int main(){
    string s1, s2;
    // 滑动窗口
    while(cin >> s1 >> s2){
        if(s1.length() > s2.length()) swap(s1, s2);
        int n = s1.length(), m = s2.length(), ans = 0;  // s1 更短
        for(int i = 1; i <= n; ++i){        // s1 尾部开始与 s2 重叠，直到 s1 完全被覆盖
            int subLen = getLen(s1, s2, n-i, n-1, 0, i-1);
            ans = max(ans, subLen);
        }

        for(int i = 1; i <= m-n; ++i){      // s1 头部与 s2 头部开始错位，直到 s1 尾部 与 s2 尾部重叠
            int subLen = getLen(s1, s2, 0, n-1, i, n+i-1);
            ans = max(ans, subLen);
        }

        for(int i = 1; i < n; ++i){         // s1 尾部超过 s2 尾部，直到不再重叠
            int subLen = getLen(s1, s2, 0, n-1-i, m-2-n+i, m-1);
            ans = max(ans, subLen);
        }

        cout << ans << endl;
    }
    return 0;
}