LeetCode: Wildcard Matching (通配符匹配)

Implement wildcard pattern matching with support for

'?'

and

'*'

.

'?' Matches any single character.
'*' Matches any sequence of characters (including the empty sequence).

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", "*") ? true
isMatch("aa", "a*") ? true
isMatch("ab", "?*") ? true
isMatch("aab", "c*a*b") ? false

首先要弄清楚什么是通配符匹配。需要注意通配符在匹配每一个字符的时候，不需要管这个字符之前的匹配结果。
这道题可以用回溯法解决。需要回溯的地方是在p中遇到一个'*'的时候，我们不能确定需要s中的几个字符去匹配这个'*'，所以就进行尝试。首先从一个都不用去匹配，如果不成功就用s中从当前字符去匹配，再不成功就用s中的下一个字符去匹配，一直这样下去，直到成功匹配或者匹配了s中的所有剩余字符。

回溯法的代码：

public boolean isMatch(String s, String p) {
// Start typing your Java solution below
// DO NOT write main() function
if (p.length() == 0) {
return s.length() == 0;
}

if (p.charAt(0) != '*') {
if (s.length() != 0 && (p.charAt(0) == s.charAt(0) || p.charAt(0) == '?')) {
return isMatch(s.substring(1), p.substring(1));
} else {
return false;
}
}

while (s.length() != 0) {
while (p.length() > 1 && p.charAt(1) == '*') {
p = p.substring(1);
}
if (isMatch(s, p.substring(1))) {
return true;
}
s = s.substring(1);
}

return isMatch(s, p.substring(1));
}

这个代码无法通过LeetCode的大集合。尝试使用迭代去解决。

由于通配符匹配的时候，可以看做分段匹配，将p根据‘*’分成不同的部分，把这些部分分别放在s中做字符串匹配，只要能匹配并且各个部分不重叠，那么最终就是匹配的。比如p = abc****d?f*ghi，p可分为三段,abc,
def, ghi。将这三段分别与s进行匹配。

需要注意的地方是第一段和最后一段的匹配。如果第一段的第一个字符不是‘*’，则第一段就需要从第一个字符开始正向进行匹配。如果最后一段的最后一个字符不是‘*’，则最后一段需要从最后一个字符开始反向匹配。

迭代实现的代码很繁琐。

public int stringMatch(String s, String p) {
int sLen = s.length();
int pLen = p.length();
int i = 0;
int j = 0;

for (; i < sLen && j < pLen; i++, j++) {
if (s.charAt(i) != p.charAt(j) && p.charAt(j) != '?') {
i = i - j;
j = -1;
}
}
if (j == pLen) {
return i - j;
} else {
return -1;
}
}

public boolean isMatch(String s, String p) {
// Start typing your Java solution below
// DO NOT write main() function
String matchStr = null;
int first = p.indexOf('*');

if (first == -1) {
// no '*' in the pattern
// s and p must exactly match
return stringMatch(s, p) == 0 && s.length() == p.length();
}

if (first > 0) {
// p does not begin with '*'
// check beginning part of p (before the first '*')
// forward match from the beginning characters of s and p
matchStr = p.substring(0, first);
int i = 0; int j = 0;
for (; i < s.length() && j < matchStr.length(); i++, j++) {
if (s.charAt(i) != matchStr.charAt(j) && matchStr.charAt(j) != '?') {
return false;
}
}
if (j < matchStr.length()) {
return false;
}
// discard matched part in s after matching
s = s.substring(matchStr.length());
}

int last = p.lastIndexOf('*');
if (last < p.length() - 1) {
// p does not end with '*'
// check last part of p (after the very last '*')
// backward match from the last characters of s and p
matchStr = p.substring(last + 1);
int i = s.length() - 1; int j = matchStr.length() - 1;
for (; i >= 0 && j >= 0; i--, j--) {
if (s.charAt(i) != matchStr.charAt(j) && matchStr.charAt(j) != '?') {
return false;
}
}
if (j >= 0) {
return false;
}
// discard matched part in s after matching
s = s.substring(0, s.length() - matchStr.length());
}

// discard matched part in p
p = p.substring(first, last + 1);

// discard consecutive '*' from the front of p
while (p.length() != 0 && p.charAt(0) == '*') {
p = p.substring(1);
}
// discard consecutive '*' from the tail of p
while (p.length() != 0 && p.charAt(p.length() - 1) == '*') {
p = p.substring(0, p.length() - 1);
}

// iteratively match the rest part of p
while (p.length() != 0) {
int star = p.indexOf('*');
if (star != -1) {
matchStr = p.substring(0, star);
} else {
matchStr = p;
}
int match = stringMatch(s, matchStr);
if (match == -1) {
return false;
}
p = p.substring(matchStr.length());
while (p.length() != 0 && p.charAt(0) == '*') {
p = p.substring(1);
}
s = s.substring(match + matchStr.length());
}

return true;
}