LeetCode10 Regular Expression Matching

题意：

Implement regular expression matching with support for '.' and '*'.

'.' Matches any single character.
'*' Matches zero or more of the preceding element.

The matching should cover the entire input string (not partial).

The function prototype should be:
bool isMatch(const char *s, const char *p)

Some examples:
isMatch("aa","a") → false
isMatch("aa","aa") → true
isMatch("aaa","aa") → false
isMatch("aa", "a*") → true
isMatch("aa", ".*") → true
isMatch("ab", ".*") → true
isMatch("aab", "c*a*b") → true   （hard）



分析：  
题目意思是  正则表达式匹配，'.'匹配任意字符， '*'表示前一个字符可以出现任意多次（0次，1次，2次...）
如ab 与 .*  :将.出现两次为..可以匹配任意字符，所有可以匹配ab 
aab 与 c*a*b :c*将c出现0次， a*将a出现两次，得到aab可以匹配。

而且特殊符号是只出现在p字符串中的（开始没理解这个导致感觉问题很复杂推不下去...，可能因为没学过正则表达式）

解析： 
采用动态规划。双序列动态规划常见得状态选取即为dp[i][j]表示s的前i个与p的前j个...
对应于本题，dp[i][j]表示s的前i个字符与p的前j个字符能否匹配。 但本题递推关系不是很好推完整（毕竟hard）
当p[j-1] != '*'
　　　　需要s[i-1] == p[j-1] 并且 dp[i-1][j-1] == true (前i-1个与前j-1个能匹配)
当p[j-1] == '*'
　　　　有如下几种情况：
　　　　1)*前的字符需要重复0次 例如匹配 ab 和 aba*， 该情况下dp[i][j]是否为真取决于 dp[i][j-2] 是否为真；
　　　　2)*前的字符需要重复1次，即其本身，如匹配 aba 和 aba*, 该情况下dp[i][j]是否为真取决于dp[i][j-1]是否为真；
　　　　3）*前字符需要重复2次或以上， 如匹配 abaa 与 aba*(出现两次)， 匹配aaa与.*(出现大于两次)；
　　　　　　该情况下需要s[i-1] == p[j-2] && (dp[i-1][j-1] || dp[i-1][j]) // dp[i-1][j]容易忽略，表示要利用*前元素大于两次；

初始化dp[0][0], dp[i][0] (i = 1,2,...s.size()) , dp[0][j], (j = 1,2,...p.size())；
其中dp[0][j]的需要点判断， p[j - 1] == '*' &&  dp[0][j - 2] （即*帮助去掉了前面的字符。开始还写了||dp[0][j-1]，后来发现*不会打头存在，所以dp[0][j-1]没必要）

代码：（还有一些小细节在注释中）

class Solution {
public:
    bool isMatch(string s, string p) {
        bool dp[s.size() + 1][p.size() + 1];
        dp[0][0] = true;
        for (int i = 1; i <= s.size(); ++i) {
            dp[i][0] = false;
        }
        for (int j = 1; j <= p.size(); ++j) {
             //p[j-2]一定存在,*不会打头！
             if (p[j - 1] == '*' &&  dp[0][j - 2])  {
                dp[0][j] = true;
            }
            else {
                dp[0][j] = false;
            }
        }
    
        for (int i = 1; i <= s.size(); ++i) {
            for (int j = 1; j <= p.size(); ++j) {
                if (p[j - 1] != '*') {
                    dp[i][j] =  (s[i - 1] == p[j - 1] || p[j - 1] == '.') && dp[i - 1][j - 1];
                }
                else {
                    //重复两次或更多   dp[i-1][j]  如：aaa与.*
                    // * 不会打头，所以p[j - 2]一定存在
                    bool b1 = (s[i - 1] == p[j - 2] || p[j - 2] == '.') && (dp[i - 1][j - 1] || dp[i - 1][j]);
                    bool b2 =  dp[i][j - 1];  //重复1次
                    bool b3 =  dp[i][j - 2];  //重复0次
                    dp[i][j] = b1 || b2 || b3;
                }
            }
        }
        return dp[s.size()][p.size()];
    }
};

学习了一下讨论区，发现递推的情况基本是一样的，有一点细微的优化。

我做的时候是先想到类似abaa 与 aba*, *前字符重复两次，所以写出了dp[i - 1][j - 1]。（标红前半句）
提交之后WA发现有情况没考虑到，即aaa与.* 即出现大于两次，所以添加了dp[i-1][j]
而现在仔细考虑，实际上只需要一句dp[i-1][j]就可以处理大于等于2次重复的情况，所以标红句可以优化为

bool b1 = (s[i - 1] == p[j - 2] || p[j - 2] == '.') &&  dp[i - 1][j];