LeeCode 10 DFS / DP

题意

传送门 LeeCode 10. 正则表达式匹配

题解

DFS

对于 ${}^{\prime }a-z^{\prime }$ 与 ${}^{\prime }{.}^{\prime }$ 只需判断字符串 $s$ 与字符规律 $p$ 的当前字符是否匹配，若匹配成功 $s,p$ 指针移动至下一位置匹配后续字符；反之，匹配失败。

考虑到 ${}^{\prime }{\ast }^{\prime }$ 匹配零个或多个前面的那一个元素，则若 $p$ 当前匹配字符的下一字符为 ${}^{\prime }{\ast }^{\prime }$，则可以匹配或不匹配当前字符，根据回溯结果判断匹配结果。

class Solution
{
public:
    bool match(string &s, string &p, int i, int j)
    {
        if (j == p.length()) return i == s.length();
        bool f = (i < s.length() && (s[i] == p[j] || p[j] == '.'));
        if (j + 1 < p.length() && p[j + 1] == '*')
        {
            return match(s, p, i, j + 2) || (f ? match(s, p, i + 1, j) : f);
        }
        return f ? match(s, p, i + 1, j + 1) : f;
    }
    bool isMatch(string s, string p)
    {
        return match(s, p, 0, 0);
    }
};

DP

将 $dfs$ 的思考写为递推式，$dp[i][j]$ 代表字符规律 $p$ 的区间 $[0,i-1]$ 与字符串 $s$ 的区间 $[0,j-1]$ 匹配的结果，$flag$ 判断字符是否匹配
$$flag=\{\begin{array}{ll}1& j==0||p[i-1]={=}^{\prime }{.}^{\prime }||p[i-1]==s[j-1]\\ 0& otherwise\end{array}$$

$$\{\begin{array}{ll}if(p[i-1]={=}^{\prime }{\ast }^{\prime })& continue\\ elseif(p[i]={=}^{\prime }{\ast }^{\prime })& dp[i+1][j]\{\begin{array}{ll}dp[i-1][j-1]||dp[i+1][j-1]||dp[i-1][j]& flag=1\\ dp[i-1][j]& otherwise\end{array}\\ else& dp[i][j]=\{\begin{array}{ll}dp[i-1][j-1]& flag=1\\ false& otherwise\end{array}\end{array}$$

class Solution
{
public:
    bool judge(char p, char s)
    {
        return s == 'X' ? 0 : (p == '.' || p == s);
    }
    bool isMatch(string s, string p)
    {
        int n = p.length(), m = s.length();
        vector<vector<bool>> dp(n + 1, vector<bool>(m + 1, 0));
        dp[0][0] = 1;
        for (int i = 1; i <= n; i++)
        {
            if (p[i - 1] == '*')
                continue;
            if (i == n || p[i] != '*')
            {
                for (int j = 1; j <= m; j++)
                {
                    dp[i][j] = judge(p[i - 1], s[j - 1]) ? dp[i - 1][j - 1] : 0;
                }
            }
            else
            {
                for (int j = 0; j <= m; j++)
                {
                    dp[i + 1][j] = judge(p[i - 1], j == 0 ? 'X' : s[j - 1]) ? (dp[i - 1][j - 1] || dp[i + 1][j - 1] || dp[i - 1][j]) : dp[i - 1][j];
                }
            }
        }
        return dp[n][m];
    }
};