44. 萬用字元匹配

給定一個字串 (s) 和一個字元模式 (p) ，實現一個支援 '?' 和 '*' 的萬用字元匹配。

'?' 可以匹配任何單個字元。
'*' 可以匹配任意字串（包括空字串）。

兩個字串完全匹配才算匹配成功。

說明:

• s 可能為空，且只包含從 a-z 的小寫字母。
• p 可能為空，且只包含從 a-z 的小寫字母，以及字元 ? 和 *。

示例 1:

輸入:
s = "aa"
p = "a"
輸出: false
解釋: "a" 無法匹配 "aa" 整個字串。

示例 2:

輸入:
s = "aa"
p = "*"
輸出: true
解釋: '*' 可以匹配任意字串。

示例 3:

輸入:
s = "cb"
p = "?a"
輸出: false
解釋: '?' 可以匹配 'c', 但第二個 'a' 無法匹配 'b'。

示例 4:

輸入:
s = "adceb"
p = "*a*b"
輸出: true
解釋: 第一個 '*' 可以匹配空字串, 第二個 '*' 可以匹配字串 "dce".

示例 5:

輸入:
s = "acdcb"
p = "a*c?b"
輸出: false

思路：

​ 經典字串匹配問題。一開始寫的是遞迴的方法，但是會超時。

先給出遞迴程式碼：

class Solution {
public:
    unordered_map<string,bool>memo;
    bool isMatch(string s, string p) {
        if(p.size()==0)return s.empty();//如果s也空就是true否則就是false
        //發現只用備忘錄還是會超時，還需要優化，那麼就把p中相鄰的*全部去掉只留一個
        string pp;
        pp.push_back(p[0]);
        for(int i=1;i<p.size();i++){
            if(p[i]=='*'&&p[i-1]=='*')continue;
            pp.push_back(p[i]);
        }
        //經典字串匹配
        return Match(s,pp,0,0);
    }
    bool Match(string s,string p,int i,int j){
        if(i==s.size()){//s匹配完了
            if(j==p.size())return true;//p也匹配完了則成功匹配
            //若p沒匹配完 如果要成功匹配 則後面一定是*
            for(;j<p.size();j++)
                if(p[j]!='*')return false;
            return true;//都是*則匹配成功
        }
        if(j==p.size()){
            //如果p匹配完了，s沒匹配完 則只需要判斷p最後一個是不是*
            if(p[j-1]=='*')return true;
            return false;
        }
        string temp=to_string(i)+','+to_string(j);  
        if(memo.count(temp))return memo[temp];
        bool res=true;
        if(s[i]==p[j]){
            res= Match(s,p,i+1,j+1);
        }else{
            //如果j位置是?
            if(p[j]=='?')res= Match(s,p,i+1,j+1);
            else if(p[j]=='*'){
                //*可以匹配任意字串 匹配s多少個字元呢？
                //可以匹配0個或者多個 有一個完成就行
                res= Match(s,p,i+1,j)||Match(s,p,i,j+1);//那這樣就會存在重複情況 採用備忘錄去優化
            }else res=false;
        }
        memo[temp]=res;
        return res;
    }
};
 

後來看了一下官方題解：

class Solution {
public:
    bool isMatch(string s, string p) {
        int m = s.size();
        int n = p.size();
        vector<vector<int>> dp(m + 1, vector<int>(n + 1));
        dp[0][0] = true;
        for (int i = 1; i <= n; ++i) {
            if (p[i - 1] == '*') {
                dp[0][i] = true;
            }
            else {
                break;
            }
        }
        for (int i = 1; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                if (p[j - 1] == '*') {
                    dp[i][j] = dp[i][j - 1] | dp[i - 1][j];
                }
                else if (p[j - 1] == '?' || s[i - 1] == p[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1];
                }
            }
        }
        return dp[m][n];
    }
};
 

確實更加巧妙，但是思路是一樣的，個人認為第一種方法思路更加清晰。（超時除外）