(leetcode #10)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

分析：

（1）注意左边是常规字符串，只有右边是正则。开始我认为左边也可能是正则，形如“a＊ab” “b＊c”，那就太复杂了。还好此题只有右边是正则。

（2）正则表达式默认合法，即不会出现 **ab.***这种歧义的非法正则

（3）左边以一个字母为单位，右边则有可能是2个字母或者一个字母为单位，这样用递归可以解决，思路上也算比较清晰

（4）如果用C＋＋写，那么string可能存在字串拷贝的情况，所以复杂度上略有冗余。可以用const string&防止拷贝的发生

（5）整体思路：从左边取出最前字符，再从右边取出第一个字符比较，右边的字符可能有以下几种：a . a* .* 。因此只需要对这几种情况进行讨论然后递归即可（复杂度当然较高，不过先解决问题再说）

class Solution {
public:
bool isMatch(string s1, string s2) {
return isMatch2(s1,s2,0,0);
}
bool isMatch2(const string& s1, const string& s2, int idx1,int idx2 ) {
//if to the end of s1
if(s1[idx1] == '\0'){
if(s2[idx2] == '\0')
return true;
else if(s2[idx2 + 1] == '\0')
return false;
else{
if(s2[idx2 + 1] == '*')
return isMatch2(s1,s2,idx1,idx2 + 2);
else
return false;
}
}

//if to the end of s2
if(s2[idx2] == '\0')
return false;
else if(s2[idx2 + 1] == '\0'){
if(s2[idx2] == s1[idx1] || s2[idx2] == '.')
return isMatch2(s1,s2,idx1 + 1,idx2 + 1);
else
return false;
}

//normal scenrio
char c1 = s1[idx1];
char c2 = s2[idx2];
char c2_next = s2[idx2 + 1];
if(c2 != '.'){
if(c2_next != '*'){
if(c1 == c2){//eg:a ab
return isMatch2(s1,s2,idx1 + 1,idx2 + 1);
}
else{//eg:a cb
return false;
}
}
else{
if(c1 == c2){//eg:a a*
return isMatch2(s1, s2, idx1 + 1, idx2) || isMatch2(s1, s2, idx1, idx2 + 2);
}
else{//eg:a b*
return isMatch2(s1, s2, idx1, idx2 + 2);
}
}
}
else{
if(c2_next != '*'){
return isMatch2(s1, s2, idx1 + 1, idx2 + 1);
}
else{
return isMatch2(s1, s2, idx1 + 1, idx2) || isMatch2(s1, s2, idx1, idx2 + 2);
}
}

return false;
}
};

好了，程序由于用的递归，其实思路还算比较清晰。测试了一下，能够击败34%的人。貌似还算一个不错的结果。但是发现大部分人的耗时非常短，所以肯定用了其他方法，而且hint也提示了，用dp。以后在研究。