[leetcode]10. Regular Expression Matching

题目

---

给定一个字符串 (s) 和一个字符模式 (p)。实现支持 '.' 和 '*' 的正则表达式匹配。

'.' 匹配任意单个字符。
'*' 匹配零个或多个前面的元素。

匹配应该覆盖整个字符串 (s) ，而不是部分字符串。

说明

---

• s 可能为空，且只包含从 a-z 的小写字母。
• p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。

示例

---

1. 输入:
   s = "aa"
   p = "a"
   输出: false
   解释: "a" 无法匹配 "aa" 整个字符串。

2. 输入:
   s = "aa"
   p = "a*"
   输出: true
   解释: '*' 代表可匹配零个或多个前面的元素, 即可以匹配 'a' 。因此, 重复 'a' 一次, 字符串可变为 "aa"。

3. 输入:
   s = "ab"
   p = ".*"
   输出: true
   解释: ".*" 表示可匹配零个或多个('*')任意字符('.')。
   说明：这里".*"可以匹配"ab"的原因是，"*"的含义是匹配零个或者多个前面的元素，这里的元素是"."而不是某个具体的字符， 即为"."重复零次或者多次，而不是将具体的字符重复零次或者多次。所以".*"可以匹配".."或者"..."，那么就可以匹配"ab"。

4. 输入:
   s = "aab"
   p = "c*a*b"
   输出: true
   解释: 'c' 可以不被重复, 'a' 可以被重复一次。因此可以匹配字符串 "aab"。

5. 输入:
   s = "mississippi"
   p = "mis*is*p*."
   输出: false

思路 

---

这里参考willaty的博客。思路如下：

动态规划，dp[i][j]取值为0或1，含义s字符串从第一个字符到第i个字符（即s[0-(i-1)]）能否匹配p[0-(j-1)]。

设s=Sx，p=Pyz

思路类似最长公共子序列，则状态转移方程为：

dp[i][j] = dp[i - 1][j - 1], 如果s[i] == p[j] || p[j] == '.'

              dp[i][j - 2], 如果p[j] == '*' && s[i] != p[j - 1]

              dp[i - 1][j] || dp[i][j - 1] || dp[i - 1][j - 1] || dp[i - 1][j - 2] || dp[i][j - 2], 如果p[j] == '*' && s[i] == p[j - 1]

稍稍解释下：

对于s和p，设各个最后一个字符为x, y，p的倒数第二字符为z，除此外前面字符设为S,P，则：

s = Sx

p = Pyz

如果x == z或z == '.'，则如果S和Py匹配，则s和p匹配，因为最后两字字母是匹配的。这就缩减了问题规模。

而对于z ==  '*'的情况，需要考虑y：

    如果x != y，则只有在s和P匹配的情况下，s和p才匹配。

    如果x == y，设匹配符号为~吧，方便，则如果S~P，S~Py，S~Pyz，Sx~P，Sx~Py，都可得出s和p匹配。

代码

---

class Solution {
public:
    bool isMatch(string s, string p) {
        
        //若s与p相等直接返回true
        if(s == p){
            return true;
        }
        
        int n = s.length();
        int m = p.length();
        
        //这里的状态空间dp[i][j]表示s的从0到第i个字符组成的字符串是否匹配p的从0到第j个字符组成的字符串（包括第i,j个字符）
        int dp[n+1][m+1];
        
        memset(dp, 0, sizeof(int)*(n+1)*(m+1));
        //dp[0][0]实际上表示的是从s中取前0个字符是否匹配从p中取前0个字符（这当然匹配）
        dp[0][0] = 1;
        
        //dp[i][0],(i从1到n)一定为0，p为空时除了空串其他什么都不匹配
        //而，dp[0][j],(j从1到m)就不一定是0了，因为除了当p为空时可以匹配空串，p=a*,或者p=a*b*之类的字符串时也可以匹配空串，
        //可以得到当p[j]=='*'时， dp[0][j] = dp[0][j-2],当p[j]!='*'时，dp[0][j]==0
        for(int i=1; i<=m; i++){
            if(p[i-1] == '*'){
                dp[0][i] = dp[0][i-2];
            }else{
                dp[0][i] = 0;
            }
        }
        
        //构造动态规划矩阵
        //因为我的代码里i,j表示第i,j个字符，所以在取s,p中字符时用了s[i-1]或p[j-1]
        for(int i=1; i<=n; i++){
            for(int j=1; j<=m; j++){
                if(p[j-1] == s[i-1]){
                    dp[i][j] = dp[i-1][j-1];
                }else if(p[j-1]=='.'){
                    dp[i][j] = dp[i-1][j-1];
                }else if(p[j-1] == '*'){
                    if(p[j-1-1]!=s[i-1] && p[j-1-1]!='.'){
                        dp[i][j] = dp[i][j-2];
                    }else{
                        dp[i][j] = dp[i][j-2] + dp[i-1][j-2] + dp[i-1][j];
                        if (dp[i][j] != 0){
                            dp[i][j] = 1;
                        }
                    }
                    
                }else{
                    dp[i][j] = 0;
                }
            }
        }
        
        if (dp[n][m] == 1)
            return true;
        else
            return false;
        
    }
};