Update 044._wildcard_matching.md

Author: 0xkookoo

docs/Leetcode_Solutions/Python/044._wildcard_matching.md

@@ -1,44 +1,165 @@
-###44. Wildcard Matching
+# 44. Wildcard Matching
 
-题目:
-<https://leetcode.com/problems/wildcard-matching/>
+**<font color=red>难度: Hard</font>**
 
+## 刷题内容
 
-难度:
+> 原题连接
 
-Hard
+* https://leetcode.com/problems/wildcard-matching/description/
 
+> 内容描述
 
+```
+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:
 
-做完Regular Expression Matching来做的这道题，按照DP思路run一下是超时，感觉是开心的，至少暂时没有报错了，有待优化，应该在dp的同时在贪心一下么。
+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
 ```
+
+## 解题方案
+
+> 思路 1
+******- 时间复杂度: O(len(s) * len(p))******- 空间复杂度: O(len(s) * len(p))******
+
+
+
+dp, 看完下面的代码就知道思路了
+
+beats 61.92%
+
+```python
 class Solution(object):
     def isMatch(self, s, p):
         """
         :type s: str
         :type p: str
         :rtype: bool
         """
-        m, n = len(s), len(p)
-        dp = [ [0 for i in xrange(n+1)] for j in xrange(m+1)]
+        t = [[False] * (len(s) + 1)  for i in range(len(p) + 1)]
+        t[0][0] = True
+        for i in range(1, len(p) + 1):
+            t[i][0] = t[i-1][0] and p[i-1] == '*'
+        for i in range(1, len(p)+1):
+            for j in range(1, len(s) + 1):
+                if p[i-1] != '*':
+                    t[i][j] = (p[i-1] == s[j-1] or p[i-1] == '?') and t[i-1][j-1] 
+                else:
+                    t[i][j] = t[i][j-1] or t[i-1][j]    
+        return t[-1][-1] 
+```
+
+
+> 思路 2
+******- 时间复杂度: O(len(s) * len(p))******- 空间复杂度: O(1)******
+
+双指针
+
+```
+Worst case Should be O(NM)
+think that s ="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" to match p ="*aaaaaab"( '*' in the beginning)
+It's easy to see 'match' is moving step by step to almost the end, each time we move 'match', we will go through the whole tail of p (after '*') until we found out 'b' is not a match. Thus it's O(NM)
+```
+
+beats 94.80%
+
+```python
+class Solution(object):
+    def isMatch(self, s, p):
+        """
+        :type s: str
+        :type p: str
+        :rtype: bool
+        """
+        ps, pp, match, star_idx = 0, 0, 0, -1
+        while ps < len(s):
+            if pp < len(p) and (p[pp] == '?' or s[ps] == p[pp]): # advancing both pointers
+                ps += 1
+                pp += 1
+            elif pp < len(p) and p[pp] == '*': # found '*', only advancing pattern pointer
+                star_idx = pp
+                match = ps
+                pp += 1
+            elif star_idx != -1: # last pattern pointer was *, advancing string pointer
+                pp = star_idx + 1
+                match += 1
+                ps = match
+            else: # current pattern pointer is not star, last patter pointer was not *， characters do not match
+                return False
+        while pp < len(p) and p[pp] == '*': # check for remaining characters in pattern
+            pp += 1
+        return pp == len(p)
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
-        dp[0][0] = 1
 
-        # init the first line
-        for i in xrange(1,n+1):
-            if p[i-1] == '*':
-                dp[0][i] = dp[0][i-1]
 
-        for i in xrange(1,m+1):
-            for j in xrange(1,n+1):
-                if p[j-1] == s[i-1] or p[j-1] == '?':
-                    dp[i][j] = dp[i-1][j-1]
-                elif p[j-1] == '*':
-                    dp[i][j] = dp[i][j-1] or dp[i-1][j]
 
-        return dp[m][n] == 1 
-```