LeetCode : Regular Expression Matching DFS/动态规划

思路：由于*匹配存在不确定性，所以使用常规解法比较麻烦。由于问题可以分解，若S的前i个字符与P的前j个字符已经匹配，则只需考察剩余的字符即可。从这个特点上，可以使用DFS。而由于无后效性，所以也可以使用DP。

1.DFS解法

讨论p当前位置处的字符，若为'*'，则s可以与p匹配0个或若干个字符，否则各自移动一个位置，对剩下的字符串递归处理。代码如下：

class Solution {
public:
    bool check(const char* s, const char* p) {
        if(*p == '\0')
            return *s == '\0' ? true : false;
        if(*(p + 1) == '*'){
            while(*s != '\0' && (*s == *p || *p == '.')){
                if(check(s, p + 2))
                    return true;
                ++s;
            }
                return check(s, p + 2);
        }
        else{
            if(*s != '\0' && (*s == *p || *p == '.'))
                return check(s + 1, p + 1);
            return false;
        }
    }
    bool isMatch(string s, string p) {
        return check(s.c_str(), p.c_str());
    }
};

2.DP解法

令dp[i + 1][j + 1]表示s的前i个字符与p的前j个字符匹配与否。当p[j] = ‘*’时，x*可以匹配0个，即dp[i + 1][j + 1] = dp[i + 1][j - 1]，也可以在此基础上匹配一个(前提是当前位置要匹配)，即dp[i + 1][j + 1] = dp[i][j + 1] && (s[i] == p[j - 1] || p[j - 1] == '.')。

初始化时要注意，当s为空串时也可以与某些p匹配，所以要进行特殊处理。代码如下：

class Solution {
public:
    bool isMatch(string s, string p) {
        bool dp[1005][1005];
        dp[0][0] = true;
        dp[0][1] = false;
        int len1 = s.size(), len2 = p.size();
        for(int j = 1; j < len2; j += 2)
            dp[0][j + 1] = p[j] == '*' ? dp[0][j - 1] : false;
        for(int i = 0; i < len1; ++i){
            dp[i + 1][0] = false;
            for(int j = 0; j < len2; ++j){
                if(p[j] == '*')
                    dp[i + 1][j + 1] = dp[i + 1][j - 1] || (dp[i][j + 1] && (s[i] == p[j - 1] || p[j - 1] == '.'));
                else
                    dp[i + 1][j + 1] = dp[i][j] && (s[i] == p[j] || p[j] == '.');
            }
        }
        return dp[len1][len2];
    }
};