Regular Expression Matching

class Solution {
public:
    bool isMatch(const char *s, const char *p) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.  
        // 1
        /*
        if (s == NULL || p == NULL) return s == p;
        if (*p == ‘\0‘) return *s == *p;
        if (p[1] != ‘*‘) {
            return (*p == *s || (*p == ‘.‘ && *s != ‘\0‘)) && isMatch(s + 1, p + 1);
        }
        
        int offset = -1;
        do {
            ++offset;
            if (isMatch(s + offset, p + 2)) return true;
        } while (s[offset] == *p || (*p == ‘.‘ && s[offset] != ‘\0‘));
        
        return false;
        */
        
        // 2
        if (s == NULL || p == NULL) return s == p;
        if (*p == ‘\0‘) return *s == *p;
        
        int slen = strlen(s), plen = strlen(p);
        vector<vector<int>> mflag(slen + 1, vector<int>(plen + 1, -1));
        mflag[slen][plen] = 1;
        for (int i = 0; i < slen; ++i) {
            mflag[i][plen] = 0;
        }
        
        return isMatchHelper(s, p, mflag, 0, 0);
    }
    
private:
    bool isMatchHelper(const char *s, const char *p, vector<vector<int>> &flag, int spos, int ppos) {
        if (flag[spos][ppos] >= 0) {
            return flag[spos][ppos] == 1;
        }
        
        bool ret = false;
        if (p[ppos + 1] != ‘*‘) {
            ret = ((s[spos] == p[ppos] || (p[ppos] == ‘.‘ && s[spos] != ‘\0‘)) && isMatchHelper(s, p, flag, spos + 1, ppos + 1));
            flag[spos][ppos] = (ret ? 1 : 0);
            return ret;
        }
        
        int offset = -1;
        do {
            ++offset;
            ret = isMatchHelper(s, p, flag, spos + offset, ppos + 2);
            if (ret) {
                flag[spos][ppos] = 1;
                return ret;
            }
        } while (s[spos + offset] == p[ppos] || (p[ppos] == ‘.‘ && s[spos + offset] != ‘\0‘));
        
        flag[spos][ppos] = 0;
        return false;
    }
    
};