leetcode题解：第10题Regular Expression Matching

https://leetcode-cn.com/problems/regular-expression-matching/

分析

这道题的难点在于存在a*这样的组合，如何处理与这种组合匹配的字符数是很棘手的问题，例如：

s = "aaa", p = "aa*"
s = "baaa", p = "ba*"

第一个例子中a*匹配2个字符，第二个例子中a*匹配3个字符。可以看出，匹配的字符数不仅与s有关，还与p中组合前面的字符有关（后面也有可能）。如果是.*这样的组合，会更加麻烦。
我一开始的想法是用双指针分别遍历s和p，在遇到a*这样的组合时通过组合后面的字符与s的匹配程度来判断a*应该匹配的字符数。这个思路实现起来很麻烦，而且由于.*的存在，太容易出错了。

解法

这是一道动态规划算法题，用dp[i][j]来表示s中的前i个字符与p中的前j个字符是否匹配。

1. 易知，当p[j] == '.' || s[i] == p[j]时，代表s的第i个字符与p的第j个字符匹配，那么dp[i][j] = dp[i-1][j-1]
2. 当p[j] == '*'时，判断起来会比较麻烦。我的想法是，找到s中的第k个字符，满足dp[k][j-2] == true，即s的前k个字符与p的前j-2个字符（去掉组合的前面那一串）匹配。再判断s中第k+1到第i个字符，是否与p中第j-1个字符匹配（要么相等，要么p[j-1] == '.'）。
   需要注意，找第k个字符要从后往前找， 否则对于下面这种情况会出错：s = "a", p = "b*a*c*"，dp[1][6]应该为true，但由于dp[0][4] == true会导致k = 0，从而把dp[1][6]判断成false。
   这样做的目的也是为了让更少的s[k+1:i]去与p[j-1]进行比较。
   这种方法挺麻烦，而且时间复杂度也会高一些，但比较容易想到。
3. 若上述两种情况都不满足，那么dp[i][j] = false

class Solution {
public:
    bool isMatch(string s, string p) {
        bool dp[s.length() + 1][p.length() + 1]; // dp[i][j]:s前i个字符与p前j个字符是否匹配
        for (int i = 0; i < s.length() + 1; ++i) dp[i][0] = false;
        for (int j = 0; j < p.length() + 1; ++j) dp[0][j] = false;
        dp[0][0] = true;
        for (int i = 0; i <= s.length(); ++i) {
            for (int j = 1; j <= p.length(); ++j) {
                if (p[j - 1] == '*') {
                    bool flag = false;
                    int k;
                    for (k = i; k >= 0; --k) {
                        if (dp[k][j - 2]) {
                            flag = true;
                            break;
                        }
                    }
                    if (!flag) {
                        dp[i][j] = false;
                        continue;
                    }
                    if (p[j - 2] == '.') dp[i][j] = true;
                    else {
                        k++;
                        flag = true;
                        while (k <= i) {
                            if (s[k - 1] != p[j - 2]) {
                                flag = false;
                                break;
                            }
                            k++;
                        }
                        dp[i][j] = flag;
                    }
                }
                else if (i == 0) dp[i][j] = false;
                else {
                    dp[i][j] = dp[i - 1][j - 1] && (s[i - 1] == p[j - 1] || p[j - 1] == '.');
                }
            }
        }
        return dp[s.length()][p.length()];
    }
};

代码如上，处理*的那里编码很繁琐，但算法运行时间倒挺快的，leetcode上只有4ms，超过了96.88%的解答，这挺奇怪，我找k和判断k+1~i应该都花了额外时间，这个算法的时间复杂度肯定不是最优的。

官方题解给出了对于第2种情况更好的处理办法，其主要思想是，要匹配a*这样的组合，不论用多少个字符去匹配，其本质都是两种选择：

1. 匹配第i个字符，将其扔掉，再继续判断是否匹配第i-1个字符
2. 不匹配第i个字符，直接将这个组合扔掉

这样的话，对于第二种情况，状态转移方程就是

1. dp[i][j] = dp[i][j-2] || dp[i-1][j]，当s[i]与p[j-1]匹配
2. dp[i][j] = dp[i][j-2]，当s[i]不与p[j-1]匹配

代码

class Solution {
public:
    bool isMatch(string s, string p) {
        bool dp[s.length() + 1][p.length() + 1]; // dp[i][j]:s前i个字符与p前j个字符是否匹配
        for (int i = 0; i < s.length() + 1; ++i) dp[i][0] = false;
        for (int j = 0; j < p.length() + 1; ++j) dp[0][j] = false;
        dp[0][0] = true;
        for (int i = 0; i <= s.length(); ++i) {
            for (int j = 1; j <= p.length(); ++j) {
                if (p[j - 1] == '*') {
                    if (i == 0 || s[i - 1] != p[j - 2] && p[j - 2] != '.') {
                        dp[i][j] = dp[i][j - 2];
                    }
                    else {
                        dp[i][j] = dp[i][j - 2] || dp[i - 1][j];
                    }
                }
                else if (i == 0) dp[i][j] = false;
                else {
                    dp[i][j] = dp[i - 1][j - 1] && (s[i - 1] == p[j - 1] || p[j - 1] == '.');
                }
            }
        }
        return dp[s.length()][p.length()];
    }
};

这个代码更加简洁明了，而且时间复杂度也减小了。

细节

首先，采用bool数组来存储状态，一定要注意初始化，因为bool的初始值并不一定是true或者false，而是随机的一个值，直接用的话容易出错。
其次，dp[0][j]并不一定全是false的，即空串也是能够满足正则表达式匹配的，例如a*就能匹配一个空串。
数组下标索引是从0开始的，所以在前面思路中的s[i]和p[j]，在代码里都要替换成s[i-1]和p[j-1]，dp相关的则不用。

复杂度分析

时间复杂度为$O(mn)$，空间复杂度为$O(mn)$。空间应该优化到$O(n)$，之后再做吧。
优化空间复杂度后的代码：

class Solution {
public:
    bool isMatch(string s, string p) {
        bool dp[p.length() + 1]; // dp[j]:s前i个字符与p前j个字符是否匹配
        for (int j = 1; j <= p.length(); ++j) dp[j] = false;
        dp[0] = true;
        for (int i = 0; i <= s.length(); ++i) {
            bool leftNor = dp[0];
            dp[0] = i == 0 ? true : false;
            for (int j = 1; j <= p.length(); ++j) {
                bool tmp = dp[j];
                if (p[j - 1] == '*') {
                    if (i == 0 || s[i - 1] != p[j - 2] && p[j - 2] != '.') {
                        dp[j] = dp[j - 2];
                    }
                    else {
                        dp[j] = dp[j - 2] || dp[j];
                    }
                }
                else if (i == 0) dp[j] = false;
                else {
                    dp[j] = leftNor && (s[i - 1] == p[j - 1] || p[j - 1] == '.');
                }
                leftNor = tmp;
            }
        }
        return dp[p.length()];
    }
};

需要特别注意的就是leftNor变量的初始化。