10. 正则表达式匹配

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];
    }
};

1. matches函数是一个辅助函数，用于判断字符串s的第i个字符是否与模式p的第j个字符匹配。如果模式中的字符是'.'，则它可以匹配任何字符；如果模式中的字符是'*'，则matches函数返回false，因为'*'不能直接与字符串中的字符匹配。

2. f是一个二维向量，用于存储动态规划的状态。f[i][j]表示s的前i个字符是否可以与p的前j个字符匹配。初始时，f[0][0]设置为true，表示两个空字符串是可以匹配的。

3. 接下来，代码使用两层循环遍历字符串s和模式p。对于每个状态(i, j)，代码根据模式p的第j个字符进行判断：

   • 如果模式中的字符是'*'，则有两种情况：一种是'*'表示0个前面的字符，这时状态转移方程为f[i][j] |= f[i][j - 2]；另一种是'*'表示至少1个前面的字符，这时状态转移方程为f[i][j] |= f[i - 1][j]。这两种情况是逻辑或的关系，所以使用了|=操作符。

   • 如果模式中的字符不是'*'，则只有一种情况：如果s的第i个字符与p的第j个字符匹配，则状态转移方程为f[i][j] |= f[i - 1][j - 1]。

4. 最后，函数返回f[m][n]，即字符串s的全部字符是否可以与模式p的全部字符匹配。

这个实现使用了动态规划的思想，时间复杂度为O(mn)，其中m和n分别是字符串s和模式p的长度。