LeetCode: 392. 判断子序列（DP）

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

你可以认为 s 和 t 中仅包含英文小写字母。字符串 t 可能会很长（长度 ~= 500,000），而 s 是个短字符串（长度 <=100）。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

示例 1:
s = “abc”, t = “ahbgdc”

返回 true.

示例 2:
s = “axc”, t = “ahbgdc”

返回 false.

【思路】：
还是由递归入手思考。
比如测试用例：s = "abc", t = "ahbgdc"
我当时就想，如果能知道ahbgd与s = "abc"的匹配个数，那么我们只需要再看t的最后一位和s的关系不就解出来了吗？
用递归思想找状态转移方程是非常方便的，很快，递归程序可以写出来了
递归程序：

class Solution {
public:
    int f(string &s, string &t, int ee)            //ss代表此时s的开头字符，ee代表此时t的最后一个字符，返回值意思：最大匹配长度
    {
        if(ee == 0)
        {
            if(t[ee] == s[0])
                return 1;
            else
                return 0;
        }
        int res = f(s, t, ee - 1);
        if(res == s.size())                      //已经匹配的长度不可能更长了
            return res;
        else
        {
            if(t[ee] == s[res])
                return res + 1;
            else
                return res;
        }
    }
    
    bool isSubsequence(string s, string t) {
        //cout << f(s, t, t.size() - 1);
        if(s.size() == 0 && t.size() == 0)
            return true;
        else if(s.size() == 0)
            return true;
        else if(t.size() == 0)
            return false;
        if(f(s, t, t.size() - 1) == s.size())
            return true;
        else
            return false;
    }
};

接下来的工作就是将它转换成dp程序，以此来达到优化的目的。这个转换过程不难，对着递归程序改写就行了，注意一点的就是，dp最好不用数组，我一开始用的是dp[500005]这样的数组，最后那一组非常大的测试数据硬是过不去，出现不知道原因的执行错误。我试了半天还是错的，几乎绝望

后来，我就想，那把dp数组改成vector 向量算了，这样应该会好点，果然，最后那组最大的测试数据一下就过了。hahahaha

AC代码：

class Solution {
public:
    vector<int> dp;
    
    int DP(string &s, string &t, int ee)            //ss代表此时s的开头字符，ee代表此时t的最后一个字符，返回值意思：最大匹配长度
    {
        if(t[0] == s[0])
            dp.push_back(1);
        else   
            dp.push_back(0);
        
        int slen = s.size();
        int tlen = t.size();
        for(int i = 1;i <= tlen - 1;i++)
        {
            if(dp[i - 1] == slen)
                dp.push_back(slen);
            else
            {
                if(t[i] == s[dp[i - 1]])
                    dp.push_back(dp[i - 1] + 1);
                else
                   dp.push_back(dp[i - 1]);
            }    
        }
        return dp[tlen - 1];
    }
    
    bool isSubsequence(string s, string t) {
        //cout << f(s, t, t.size() - 1);
        if(s.size() == 0 && t.size() == 0)
            return true;
        else if(s.size() == 0)
            return true;
        else if(t.size() == 0)
            return false;
        if(DP(s, t, t.size() - 1) == s.size())
            return true;
        else
            return false;
    }
};

dp题都是用递归进行思考，然后再改写成dp程序就非常简单了！