LeetCode - Wildcard Matching

Wildcard Matching

2014.2.28 01:49

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

Solution:

　　At first I tried to implement an O(n * m) solution with dynamic programming and a 2d array, but it proved to be neither efficient nor easy-to-write. I gave up.

　　'*' is the key point in wildcard matching, because you can skip arbitrary number of letters when '*' is encountered, while for other letter or '?' you always go one step forward.

　　Let's think about what you do when a mismatch happens: s[]="abcde" p[]="abcf". You can't just return false, because '*' means more possibilities.

　　See this: s[]="abcxxadc" p="abc*abc". The bold part is the longest match, and the italic is unabled to be matched.

　　If you find a letter in p is mismatched, you can seek the last '*' and start searching from the next letter to that '*'. Consecutive '*'s are regarded as one.

　　Why is this backtracking correct? Because you can cover those consecutive mismatched letters with one '*', as long as there is one '*' available. Those non-star letters have to be strictly matched.

　　The algorithm requires the pattern to be completely matched, so partial match is considered mismatch.

　　Total time complexity is O(len(s) + len(p)). Space complexity is O(1).

Accepted code:

// 2CE, 4WA, 1AC, O(m + n) solution, not so easy to understand.
#include <cstring>
using namespace std;

class Solution {
public:
bool isMatch(const char *s, const char *p) {
if (s == nullptr || p == nullptr) {
return false;
}

int ls, lp;

ls = strlen(s);
lp = strlen(p);

if (ls == lp && lp == 0) {
return true;
}

if (lp == 0) {
return false;
}

// from here on, ls and lp are guaranteed to be non-zero.
int i, j;
int last_star_p;
int last_star_s;

i = j = 0;
last_star_p = -1;
last_star_s = 0;
while (j < ls) {
if (p[i] == '?' || p[i] == s[j]) {
++i;
++j;
} else if (p[i] == '*') {
last_star_p = i;
++i;
last_star_s = j;
} else if (last_star_p != -1) {
// backtrack to the last '*', and move to the next letter in s
i = last_star_p + 1;
j = last_star_s + 1;
++last_star_s;
} else {
return false;
}
}
while (p[i] == '*') {
// skip the trailing stars
++i;
}

return i == lp;
}
};