Regular Expression Matching

'.' 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

使用递归。

对于 pattern p, indexP 对应当前访问的 char, indexP + 1 对应下一个 char.

case 1 : if (p.charAt(indexP + 1) != '*')

如果下一个 char (char at indexP + 1) 不是 ‘*’， 即 if (p.charAt(indexP + 1) != '*'), 那么必须要求当前的 char at indexP 和 char at indexS 是对应的。

例如： s: ...... a b......

p: ...... cc
......

pp+1

这里 index p+1 的位置， char != '*' , 那么如果 在 index p 的位置上不对应， 则直接返回 false， 因为到这一层 p之前的部分匹配成功，但到p 的位置，匹配已经失败了，而且 p + 1 不是 ‘*’， 没法跳过 p。

例如： s: ...... a b
......

p: ...... ac
......

p p+1

在这个例子中，p 的位置对应的 char 是一样的，匹配成功，那么就进入下一层递归调用matchHelper(s, p, indexS + 1, indexP + 1)。
至于 p + 1 位置上的 b 和 c 不对应，那是下一层递归的任务，当进入下一层后，原来的 p + 1 就变成了 p。

case 2 : if (p.charAt(indexP + 1) == '*')

第二种情况是，当下一个 char 是 ‘*’ 时。

此时意味着当前index 对应的 char 可以出现0次或者多次。

但是到底是匹配几个才是最后成功匹配的个数呢？

例如：

s:
a a ab

p: a
* b

用 * 匹配了三个。

s:
a a ab

p: a
* a b

用 * 匹配了两个个。
在没有进行后续部分的比较前，没法确定到底应该用 * 匹配几个，才是应该使用的正确个数。因此方法就是把所有可能匹配上的个数都试一遍。因此 从 0 ~ n 个可以用 * 匹配上 s 的后续的 char 的，都调用一次递归，如果某一种个数最后成功完成了匹配，就 return true， 否则继续用 * 匹配 s 的下一个 char.

直到 s 中 所有可以与当前 * 匹配的都匹配完，即失去与 * 的匹配后，却没有一次成功的匹配并return true. 则跳过 * （indexP + 2），继续后续的递归：

// until we get char at indexS != charAt indexP

return matchHelper(s, p, indexS, indexP + 2);

s s+1s+2s+3s+4

例子： s: ...... a a
a ac ......

p: ...... a*
......

p p+1p + 2

这里 p + 1 是 ‘*’

循环第一次，调用 if (matchHelper(s, p, indexS, indexP + 2)) {return true;}，也就是 a* 没有和 s ... s+4 的任何一个a匹配，直接跳过

循环第二次， s++, 此时indexS指在 s + 1. 也就是 a* 匹配了一个 a， 然后跳过a*, 进入后续的比较

循环第三次 s++, 此时indexS指在 s + 2. 也就是 a* 匹配了两个 a， 然后跳过a*, 进入后续的比较

...

（这期间如果有一次的组合是证明成功的，就会return true，因为在 if 里调用了递归）

最后 indexS 到 s + 4（a* 匹配了s中所有可以匹配的a）， 此时说明之前的几次都没匹配成功，则继续进入后续的调用：

// until we get char at indexS != charAt indexP

return matchHelper(s, p, indexS, indexP + 2);

public boolean matchHelper(String s, String p, int indexS, int indexP) {
// 当匹配进行到最后，s 和 p的指针超出了末尾
if (indexP == p.length()) {
return indexS == s.length();
}

// 当匹配进行到最后，s 和 p的指针到达了末尾，且相等
if (indexP == p.length() - 1) {
return indexS == s.length() - 1
&& (s.charAt(indexS) == p.charAt(indexP) || p.charAt(indexP) == '.');
}

// next char != '*'
// 若此时 s 和 p 匹配不上，则return false
if (p.charAt(indexP + 1) != '*') {
if (indexS < s.length() && (s.charAt(indexS) == p.charAt(indexP) || p.charAt(indexP) == '.')) {
return matchHelper(s, p, indexS + 1, indexP + 1);
} else {
return false;
}
} else {
// next char == '*'
// 用 while loop 和 递归把所有匹配的个数都尝试一遍
while (indexS < s.length() && (s.charAt(indexS) == p.charAt(indexP) || p.charAt(indexP) == '.')) {
if (matchHelper(s, p, indexS, indexP + 2)) {
return true;
}
indexS++;
}
// until we get char at indexS != charAt indexP
// 之前的递归调用都没有返回 true,
// 此时 * 匹配了当前 s 中后续所有可以匹配的重复char, 跳过 * 继续往后
return matchHelper(s, p, indexS, indexP + 2);
}
}

public boolean isMatch(String s, String p) {
return matchHelper(s, p, 0, 0);
}