leetcode.cn 10.正则表达式匹配 记忆化搜索

心血来潮想刷刷题玩，想起leetcode，注册登录，知道leetcode上的题都比较简单，就勾选难度为“困难”，然后看到此题。

读完题，心想这标为“困难”，该不会是得用DFA甚至NFA吧？

又仔细看了下测试数据，数据量不大，直接搜索吧，暴搜如果超时，再考虑剪枝或者加记忆化。

花了二十多分钟敲完代码，交上去，果然TLE。不过，leetcode比OJ人性化啊，还告诉我超时前最后执行的是"aaaaaaaaaaaaab" "a*a*a*a*a*a*a*a*a*a*c"这组测试数据，于是我改进了下模式串的处理，再交，还是超时，不过已经不提示是哪组超时了，估计是所有测试数据运行的总时间超了吧。

没办法那还是加记忆化吧。也很简单，就是加个标记数组hasjudged，加几行代码把搜过的记录一下避免下次重复搜就行。再交，就过了。真简单，这种题在ACM/ICPC只能算水题吧。^_^

int extend_pattern(string p, char* pstr) {
    int I = 0;
    for (int i = 0, n = p.size(); i < n; i++) {
        pstr[I++] = p[i];
        if (i + 1 < n && p[i + 1] == '*') {
            pstr[I++] = '*';
            i++;
        } else {
            pstr[I++] = '1';
        }
        // 合并模式串
        if (I >= 4) {
            // 暂时只合并这一种
            if (pstr[I - 4] == pstr[I - 2] && pstr[I - 1] == '*' && pstr[I - 3] == '*') {
                I -= 2;
            }
        }
    }
    pstr[I] = 0;
    //cout << pstr << endl;
    return I;
}

inline bool is_match(char a, char b) {
    if (b == '.') {
        return a != '\0';
    }
    return a == b;
}

bool hasjudged[22][32];

bool is_match(const char* str, int sn, const char* pstr, int pn) {
    //cerr << sn << " " << pn << endl;
    if (sn == 0 && pn == 0) {
        return true;
    }
    if (pn == 0) {
        return false;
    }
    if (hasjudged[sn][pn]) {
        return false;
    }
    if (pstr[1] == '1') {
        // 这里没有单独考虑str已经用完的情况，因为空字符跟其它字符不会匹配
        if (!is_match(str[0], pstr[0])) {
            hasjudged[sn][pn] = true;
            return false;
        }
        bool ret = is_match(str + 1, sn - 1, pstr + 2, pn - 1);
        hasjudged[sn][pn] = true;
        return ret;
    }
    if (is_match(str, sn, pstr + 2, pn - 1)) {
        return true;
    }
    for (int i = 0; i < sn; i++) {
        if (!is_match(str[i], pstr[0])) {
            break;
        }
        if (is_match(str + i + 1, sn - i - 1, pstr, pn)) {
            return true;
        }
    }
    hasjudged[sn][pn] = true;
    return false;
}

class Solution {
public:
    bool isMatch(string s, string p) {
        memset(hasjudged, 0, sizeof(hasjudged));
        char pstr[80];
        int pn = extend_pattern(p, pstr);
        int sn = s.length();
        return is_match(s.c_str(), sn, pstr, pn / 2);
    }
};