CP10 正则表达式匹配

题目描述：

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。'.' 匹配任意单个字符；'*' 匹配零个或多个前面的那一个元素；所谓匹配，是要涵盖整个字符串 s的，而不是部分字符串。

学习：

如果逐位判断，'.'视作相同，'*'要看上一位的，如果上一位是'.'视作相同，是别的字符在进行判断。写完后发现，'*'是匹配零个或多个，不是一个或多个，我真的哭死，难绷，然后修改错误百出，需要考虑的情况也是非常多的。看看下面的代码是不是觉得还挺正确的：

//错误的代码
class Solution {
public:
    bool isMatch(string s, string p) {
        int i=0;int j=0;
        for(i=0;i<p.length()&&j<s.length();i++)
        {
            char a=s[j];char b=p[i];
            if(a==b || b=='.')
            {
                j++;
            }
            else
            {
                if(b=='*')
                {
                    char c=p[i-1];
                    if(c=='.')
                    {
                        j++;
                    }
                    else
                    {
                        while(j<s.length()&&s[j]==c)
                        {
                            j++;
                        }
                    }
                }
                else if(p[i+1]=='*')
                {
                    i++;
                }
            }
        }
        if(j<s.length()||i<p.length()) return false;
        return true;
    }
};

但是输入是"aaa" "a*a"的时候就出现了错误，也就是说并不是一个一直向后的查找，可能需要向前看，需要全局的进行规划，太菜，去看了题解，是采用的动态规划的方法（我算法是真的菜👎）

class Solution {
public:
    bool isMatch(string s, string p) {
        int m = s.size();
        int n = p.size();

        auto matches = [&](int i, int j) {
            if (i == 0) {
                return false;
            }
            if (p[j - 1] == '.') {
                return true;
            }
            return s[i - 1] == p[j - 1];
        };

        vector<vector<int>> f(m + 1, vector<int>(n + 1));
        f[0][0] = true;
        for (int i = 0; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                if (p[j - 1] == '*') {
                    f[i][j] |= f[i][j - 2];
                    if (matches(i, j - 1)) {
                        f[i][j] |= f[i - 1][j];
                    }
                }
                else {
                    if (matches(i, j)) {
                        f[i][j] |= f[i - 1][j - 1];
                    }
                }
            }
        }
        return f[m][n];
    }
};

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/regular-expression-matching/solution/zheng-ze-biao-da-shi-pi-pei-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

然后，还在CSDN上参考了这个uu的文章，是用的递归的思想正则表达式匹配，但是去试了试超时了，因为递归只是划分成小问题，但是对于重复问题重复计算，因此动态规划学起来...