最长公共子序列

原题在这里：

题意就不多说了，

　　analyse：

　　　　定义dp[i][j]表示两字符串s1[0,i]和s2[0,j]区间的最长公共子序列长度

　　　　转移方程：

　　　　　　对于每一个i去遍历s2，有初始化dp[i][j]=max(dp[i-1][j],dp[i][j-1])

　　　　　　当有匹配位置时候也即s1[i]==s2[j],dp[i][j]=max(dp[i][j],dp[i-1][j-1]+1)

code:

 

class Solution
{
public:
    int longestCommonSubsequence(string text1, string text2)
    {
        /*
        analyse:
            定义dp[i][j]表示在s1(i)s2(j)中的最长公共子序列长度
            每层用i去遍历s2
            dp[i][j]=max(dp[i-1][j],dp[i][j-1])
            当i,j匹配
                dp[i][j]=max(dp[i][j],dp[i-1][j]+1),当前匹配位置i大于上一个匹配位置i-1 对应的j
            单独用数组表示每一个j的上一次匹配位置，从前往后dp

            修改转移方程：
            dp[i][j]=max(dp[i][j],dp[i-1][j-1]+1)
        */
        int l1 = text1.length(), l2 = text2.length(), ans = 0;
        vector<vector<int>> dp(l1 + 1, vector<int>(l2 + 1, 0));
        for (int i = 1; i <= l1; ++i)
            for (int j = 1; j <= l2; ++j)
            {
                dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);
                if (text1[i - 1] == text2[j - 1])
                    dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1);
            }
        // int num = 0;
        // for (auto i : dp)
        // {
        //     for (int j : i)
        //         cout << j << ' ';
        //     cout << text1.substr(0, num++) << endl;
        // }
        return dp[l1][l2];
    }
};

 

但是，但是，但是，我刚开始想转移方程的时候

在有效匹配位置一直思考怎么保证是当前i,j匹配是未匹配的位置

就一直想着多一个数组来标记下标i的上一个匹配位置是id[i],

　　那么，下一个位置匹配就一定需要满足j>id[i-1]

　　　　但是，这样写还是不对，比如s1：“abcba”与s2：“abcbcba”

　　　　　　在s1的第一个'a'去遍历s2找匹配的时候，会将s2的首末两个a都匹配掉，且更新状态为末尾位置，然后在后续遍历的时候第二个'a'就会找不到匹配位置

　　　　　　然后我又想当然式的加入break，但是break又不能满足全部状态的转移，所以还是错误

想来想去，突然发现dp[i-1][j-1]就是一定满足i与j是未匹配的，所以就有了转移方程，并不需要什么标记数组　　

 

同类型变换题目在这里，

　　题意是要求使得两字符串相同的删除最小的字符数量

　　　　　很显然，数量ans=l1+l2-dp[l1][l2]

code:

 

class Solution
{
public:
    int minDistance(string word1, string word2)
    {
        int l1 = word1.length(), l2 = word2.length();
        vector<vector<int>> dp(l1 + 1, vector<int>(l2 + 1, 0));
        for (int i = 1; i <= l1; ++i)
        {
            for (int j = 1; j <= l2; ++j)
            {
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                if (word1[i - 1] == word2[j - 1])
                    dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1);
            }
        }
        return l1 + l2 - 2 * dp[l1][l2];
    }
};

 

 

 

【Over】