LeetCoder_____ 通配符匹配(44)

1. 思路A

很显然可以使用dp，令dp[i][j] 表示s,p 字符串前i , j个字符是否可以匹配，而且状态转移方程也很容易推导

• 默认dp[0][0] = true
• 如果s[i] == p[j] || p[j] == ‘?’ 并且 dp[i][j] = true，那么dp[i + 1][j + 1] = true
• 如果p[j] = ‘*’ 并且 dp[i][j] = true，那么 dp[i ~ n][j + 1] = true

2.代码A

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

3. 思路B

尝试使用递归回溯解决这个问题，递归思路很简单。但是很遗憾，超时了。

4.代码B

class Solution {
public:
    bool isMatch(string s, string p) {
        return ismatch(s, p, 0, 0);
    }
    
    bool ismatch(string s, string p, int n, int m)
    {
        if(m == p.size())
        {
            return n == s.size();
        }
        
        if(p[m] == '*')
        {
            bool ret = false;
            for(int i = n; i <= s.size(); ++i)
            {
                ret = ret || ismatch(s, p, i, m + 1);
            }
            return ret;
        }
        
        if(p[m] != '?' && p[m] != s[n]) return false;
        
        return ismatch(s, p, n + 1, m + 1);
    }
    
};

5. 思路C

模拟有限状态机DFA的匹配思路，将模式串变成一个DFA，匹配字符串的过程就是状态的转变。
last 是记录*上一次匹配的位置, pos 是记录*的位置

6.代码C

class Solution {
public:
    
    bool isMatch(string s, string p) {
        int i = 0, j = 0;
        int last = -1, pos = -1;
        for(; i < s.size();)
        {
            if(j < p.size() && (p[j] == '?' || p[j] == s[i]))
            {
                ++i;++j;
            }
            else if(p[j] == '*')
            {
                last = i;
                pos = ++j;
            }
            else if(pos > 0)
            {
                j = pos;
                i = ++last;
            }
            else return false;
        }
        for(; j < p.size() && p[j] == '*'; ++j);
        return j == p.size();
        
    }
};

7. 思路D

仔细想了下，其实C思路和B思路本质并无区别，只是在写法上B使用了递归（函数开销和递归栈使得时间和空间更加消耗）。但是按道理不应该C几乎0MS通过，而B超时。
实际上在good-case(就是可以匹配得上的case)的情况下;B和C的匹配时间复杂度其实是相当的。
但是在bad-case上，B的复杂度远远超过C的复杂度。
原因就在于：

当匹配到一个*的时候，上一个*的回溯就不必考虑了。

因为B的回溯并没有考虑到这一点，所以遇到bad-case会将所有的*进行回溯导致超时。

所以，对B的代码进行优化，添加一个flag，如果遇到*之后就将flag变为true,前面的*的回溯就直接返回了。

8.代码D

class Solution {
public:
    bool isMatch(string s, string p) {
        bool flag = false;
        return ismatch(s, p, 0, 0, flag);
    }
    
    bool ismatch(string s, string p, int n, int m, bool& flag)
    {
        if(m == p.size())
        {
            return n == s.size();
        }
        
        if(p[m] == '*')
        {
            for(int i = n; i <= s.size(); ++i)
            {
                if(ismatch(s, p, i, m + 1, flag)) return true;
                if(flag) return false;
            }
            flag = true;
            return false;
        }
        if(p[m] != '?' && p[m] != s[n]) return false;
        return ismatch(s, p, n + 1, m + 1, flag);
    }
    
};