一、1143. 最长公共子序列

LeetCode：1143. 最长公共子序列
这是一道典型的二维动态规划问题，甚至面试都能被面到。

这算是一个很简单的动态规划题，很容易想到解决方案：

定义dp数组，dp[i][j]表示text1前i个字符和text2前j个字符的最长公共子序列。

当text1[i - 1] == text2[j - 1]时，显然有dp[i][j] = dp[i - 1][j - 1] + 1

当text1[i - 1] != text2[j - 1]时，我们不能简单的认为dp[i][j] = dp[i - 1][j - 1] ，因为这样的话你并没有考虑新加入的两个字符对结果的影响，比如$abcd和abdc$，他们最后一个字符不相同，但是第二个字符串的最后一个字符和第一个字符串的第三个字符相同，因此dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])，即将新加入的两个字符的影响也考虑进去。

时间复杂度：$O(nm)$

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

二、求最长公共子序列

这个问题在南大计科面试G组中有被问到

实际上和之前的区别是，这里需要求出子序列具体是什么。而我们知道对于两个字符串而言，他们的最长公共子序列是相同的。

动态规划：
由于公共子序列是相当于两个字符串而言的，因此我们不能只保存一个字符串中公共子序列的信息，因为你不知道它相对于另一方的那段而言的。

为了进行状态转移和最终得到子序列，我们需要求出text1[i]和text2[j]的最长公共子序列的末尾下标。使用pair<int,int> sdp[n][m];

当text1[i] == text2[j]时，sdp[i][j] = {i,j};
当text1[i] != text2[j]时，if dp[i - 1][j] > dp[i][j - 1] then sdp[i][j] = sdp[i - 1][j] else sdp[i][j] = sdp[i][j - 1];

string LCS(string a, string b){
    string t;
    vector<vector<int>> dp(a.size() + 1, vector<int>(b.size() + 1, 0));
    vector<vector<pair<int, int>>> sdp(a.size() + 1, vector<pair<int, int>>(b.size() + 1, {0, 0}));
    for(int i = 1; i <= a.size(); ++ i){
        for(int j = 1; j <= b.size(); ++ j){
            if(a[i - 1] == b[j - 1]){
                dp[i][j] = dp[i - 1][j - 1] + 1;
                sdp[i][j] = {i, j};
            }else{
                if(dp[i - 1][j] > dp[i][j - 1]){
                    sdp[i][j] = sdp[i - 1][j];
                    dp[i][j] = dp[i - 1][j];
                }else{
                    sdp[i][j] = sdp[i][j - 1];
                    dp[i][j] = dp[i][j - 1];
                }
            }
        }
    }
    for(pair<int, int> i = sdp[a.size()][b.size()]; i.first >= 1 && i.second >= 1; ){
        t.push_back(a[i.first - 1]);
        i = sdp[i.first - 1][i.second - 1];
    }
    reverse(t.begin(), t.end());
    return t;
}

利用dp信息回溯：
实际上，从后往前看，每次遇到的两个字符串中第一个相同的字符一定是公共子序列上的。因此我们从后往前遍历，我们如何判断呢？如果a[i]是公共子序列上的字符而b[j]不是，那么必然有dp[i - 1][j] < dp[i][j - 1]，也就是a[i]被去除之后公共子序列少了一个，因此b[j]无用的话，直接--j这样可以找到和a[i]相同的字符串。同理如果dp[i - 1][j] > dp[i][j - 1]，说明b[j]是公共子序列上的一员，而a[i]不是，因此可以直接--i。

string LCS(string a, string b) {
    int n = a.size(), m = b.size();
    vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));

    // 填充 dp 数组
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            if (a[i - 1] == b[j - 1]) {
                dp[i][j] = dp[i - 1][j - 1] + 1;
            } else {
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
            }
        }
    }

    // 回溯构建 LCS
    string t;
    int i = n, j = m;
    while (i > 0 && j > 0) {
        if (a[i - 1] == b[j - 1]) {
            t.push_back(a[i - 1]);
            --i; --j;
        } else if (dp[i - 1][j] > dp[i][j - 1]) {
            --i;
        } else {
            --j;
        }
    }
    
    reverse(t.begin(), t.end());
    return t;
}

三、变式

一、1035. 不相交的线

LeetCode：1035. 不相交的线

这个题完全就是最长公共子序列问题，代码都不用改。

二、1312. 让字符串成为回文串的最少插入次数

LeetCode：1312. 让字符串成为回文串的最少插入次数

困难题，确实很难想，直观想法是从左右两边开始往中间遍历，依次判断字符是否相等来判断是否需要插入，如果相等则不需要，如果不相等则需要，但这样是不行的因为不相等的时候插入哪个字符呢？这很难判断。原因在于这俩其中有一个字符很可能与往中间去的某个字符相匹配，因此需要插入的是另一个。

回文序列实际上就是两边回文相同的序列，现在要求的实际上就是要求插入之后两边相同。那么我们选择一个转变后答案的回文中心的位置（我们在插入前并不知道是哪个，但他一定存在），然后是不是使得两边不同的字符串变成同一个就行了。

这实际上就是看公共子序列有多少个了，我们可以考察这样的问题：

$将字符串str1和str2变成相同的需要插入多少字符$

这不是编辑距离吗？ 不是！编辑距离可以增删改，这里只能增加。当然仔细思考可以发现，使用动态规划他们俩大同小异。

这个问题可以转化成最长公共子序列问题，求出$str1和str2最长公共子序列长度k$，然后答案就是len(str1)+len (str2)-2k。You ask why？变成相同，原来相同的是不是就不用动了，可以当作一个板子隔开字符串的各个部分，然后各个部分都是互不相同的，然后互相添加对方相同的部分即可。 那为什么要利用这些相同的呢？ 不利用的话就谁都不和谁相同，直接没相同的了。understand？

那么最后这个困难题，就可以转换成，以每个可能的回文中心为中点，求两边字符串的最长公共子序列了，求出来之后就可以求出来插入多少个两边就会相同，并且在所有回文中心中取最小即可。（我们不知道哪个回文中心最好使）

时间复杂度：$O(n^2)$

class Solution {
public:
    int minInsertions(string s) {
        int n = s.size();
        vector<vector<int>> dp(n + 1,vector<int>(n + 2, 0));
        
        int num = 0x3f3f3f3f;
        for(int i = 1; i <= n; ++ i){
            for(int j = n; j >= i; -- j){
                if(s[i - 1] == s[j - 1]){
                    dp[i][j] = dp[i - 1][j + 1] + 1;
                }else{
                    dp[i][j] = max(dp[i - 1][j], dp[i][j + 1]);
                }
                if(i == j || i == j - 1)//两种回文序列的情况，一个是奇数，一个是偶数。
                    num = min(i + (n + 1) - j - 2 * dp[i][j], num);
            }
        }
        return num;
    }
};