leetcode_53 Wildcard Matching

题目：通配符匹配

Given an input string (s) and a pattern (p), 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).

Note:

• s could be empty and contains only lowercase letters a-z.
• p could be empty and contains only lowercase letters a-z, and characters like ? or *.

Example 1:

Input:
s = "aa"
p = "a"
Output: false
Explanation: "a" does not match the entire string "aa".

Example 2:

Input:
s = "aa"
p = "*"
Output: true
Explanation: '*' matches any sequence.

Example 3:

Input:
s = "cb"
p = "?a"
Output: false
Explanation: '?' matches 'c', but the second letter is 'a', which does not match 'b'.

Example 4:

Input:
s = "adceb"
p = "*a*b"
Output: true
Explanation: The first '*' matches the empty sequence, while the second '*' matches the substring "dce".

Example 5:

Input:
s = "acdcb"
p = "a*c?b"
Output: false

方法一： 使用回溯法TLE

class Solution {
public:

    bool backtraceMatch(string s,string p)
    {
        if(s[0] == '\0' || p[0] == '0')
        {
            if(s[0] == '\0' && p[0] == '\0')
               return true;
            //if(s[0] == '\0' && (p.length()==1 && p[0] == '*'))
            if(s[0] == '\0')
            {
                int i = 0;
                while(p[i] != '\0')
                {
                    if(p[i] == '*')
                        i++;
                    else
                        break;
                }
                if(p[i] == '\0')
                     return true;
            }
            return false;
        }
        if(s[0] == p[0] || (s[0] != '\0' && (p[0] == '?')))
            return backtraceMatch(s.substr(1), p.substr(1));
        if(p[0] == '*'){
            return backtraceMatch(s.substr(1),p) || backtraceMatch(s,p.substr(1));
        }
        return false;
    }
    
    bool isMatch(string s, string p) {
        if(p.length() == 0)
            return (s.length() == 0);
        return backtraceMatch(s,p);        
    }
};

方法二：非递归回溯

class Solution {
public:
    bool isMatch(string s, string p) {
        char* s1 = &s[0];
        char* p1 = &p[0];
        char* star = NULL;
        char* ss = s1;
        while(*s1)
        {
            if(*p1 == '?' || *p1 == *s1)
            {
                p1++;
                s1++;
                continue;
            }
            if(*p1 == '*')  /* skip star  (s,p + 1) */
            {
                star = p1;
                ss = s1;
                p1++;
                continue;
            }
            if(star)       /* backtrace  (s + 1,p),(s + 1,p + 1) */
            {
                p1 = star + 1;
                s1 = ++ss;
                ss = s1;
                continue;
            }
            return false;
        }
        while(*p1 == '*')
        {
           p1++; 
        }
        return !*p1;
    }
};