[Swift]LeetCode44. 通配符匹配 | Wildcard Matching

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9907424.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

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

---

给定一个字符串 (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

---

36ms

class Solution {
    func isMatch(_ s: String, _ p: String) -> Bool {
        var stringIndex = 0
    var patternIndex = 0
    var match = 0
    var starIndex = -1
    
    let ss = s.utf8CString
    let sCount = ss.count - 1
    let pp = p.utf8CString
    let pCount = pp.count - 1
    
    let q = "?".utf8CString.first!
    let star = "*".utf8CString.first!
    
    while stringIndex < sCount {
        if patternIndex < pCount
            && (pp[patternIndex] == q
                || pp[patternIndex] == ss[stringIndex]) {
            stringIndex += 1
            patternIndex += 1
        } else if patternIndex < pCount && pp[patternIndex] == star {
            starIndex = patternIndex
            match = stringIndex
            patternIndex += 1
        } else if starIndex != -1 {
            patternIndex = starIndex + 1
            match += 1
            stringIndex = match
        } else {
            return false
        }
    }
    
    while patternIndex < pCount && pp[patternIndex] == star {
        patternIndex += 1
    }
    
    return patternIndex == pCount
    }
}

---

48ms

class Solution {
    func isMatch(_ s: String, _ p: String) -> Bool {
        var sIndex = 0
        var pIndex = 0
        
        var pArray = Array(p)
        var deleteArray = Array<Int>()
        for (index,value) in pArray.enumerated() {
            if index > 0 && value == "*" && value==pArray[index-1] {
                deleteArray.append(index)
            }
        }
        
        for index in deleteArray.reversed() {
            pArray.remove(at:index)
        }
        
        var sArray = Array(s)
        
        var sPreIndex = -1
        var pPreIndex = -1
        
        while sIndex < sArray.count {
            if pIndex >= pArray.count {
               if sPreIndex != -1 && pPreIndex != -1 {
                    sIndex = sPreIndex
                    pIndex = pPreIndex
                    sPreIndex = -1
                    pPreIndex = -1
                    continue
                }
                return false
            } else if (pArray[pIndex] != "*" && pArray[pIndex] != "?") && pArray[pIndex] != sArray[sIndex] {
               if sPreIndex != -1 && pPreIndex != -1 {
                    sIndex = sPreIndex
                    pIndex = pPreIndex
                    sPreIndex = -1
                    pPreIndex = -1
                    continue
                }
                return false
            } else if pArray[pIndex] == "?" {
                pIndex = pIndex + 1
                sIndex = sIndex + 1
            } else if pArray[pIndex] == "*" {
                //case 0: * is the last char
                if pIndex == pArray.count - 1 {
                    return true
                }
                
                //case 1: * == null
                //case 2: * == multiple char
                pIndex = pIndex + 1
                while sIndex < sArray.count {
                    if checkMatch(sArray[sIndex],pArray[pIndex]) {
                        pPreIndex = pIndex - 1
                        sPreIndex = sIndex + 1
                        pIndex = pIndex + 1
                        sIndex = sIndex + 1
                        break
                    }
                    sIndex = sIndex + 1
                }
            } else if pArray[pIndex] == sArray[sIndex] {
                pIndex = pIndex + 1
                sIndex = sIndex + 1
            } else if pArray[pIndex] != sArray[sIndex] {
               if sPreIndex != -1 && pPreIndex != -1 {
                    sIndex = sPreIndex
                    pIndex = pPreIndex
                    sPreIndex = -1
                    pPreIndex = -1
                    continue
                }
                return false
            }
        }
        if pIndex != pArray.count && !(pIndex == pArray.count - 1 && pArray[pIndex] == "*" ){
            return false
        }
        return true
    }
    
    func checkMatch(_ char1: Character, _ char2:Character) -> Bool {
        if char1 == char2 || char2 == "?" {
            return true
        } else {
            return false
        }
    }
    
}

---

80ms

class Solution {
    func isMatch(_ s: String, _ p: String) -> Bool {
        if s.count == 0 && p.count == 0 {
            return true
        }
        var sc = 0
        var pc = 0
        var startIndex = -1
        var last = -1
        
        var sA = Array(s)
        var pA = Array(p)
        
        while sc < s.count {
            if pc < p.count && (sA[sc] == pA[pc] || pA[pc] == "?") {
                sc += 1
                pc += 1
            } else if pc < p.count && pA[pc] == "*" {
                startIndex = pc
                last = sc
                pc += 1
            } else if startIndex != -1 {
                pc = startIndex + 1
                last += 1
                sc = last
            } else {
                return false
            }
        }
        
         while (pc < p.count && pA[pc] == "*") {
            pc += 1
         }
        
        return pc == p.count
    }
}

---

160ms

class Solution {
    func isMatch(_ s: String, _ p: String) -> Bool {
        var sIndex = 0
        var pIndex = 0
        var match = 0
        var startIndex = -1
        while sIndex < s.count {
            if pIndex < p.count && (p[pIndex] == "?" || s[sIndex] == p[pIndex]) {
                sIndex += 1
                pIndex += 1
            } else if pIndex < p.count && p[pIndex] == "*" {
                startIndex = pIndex
                match = sIndex
                pIndex += 1
            } else if startIndex != -1 {
                pIndex = startIndex + 1
                match += 1
                sIndex = match
            } else {
                return false
            }
        }
        while pIndex < p.count && p[pIndex] == "*" {
            pIndex += 1
        }
        return pIndex == p.count
    }
}

private extension String {
    subscript(index: Int) -> Character {
        return self[self.index(self.startIndex, offsetBy: index)]
    }
}

---

716ms

class Solution {
    func isMatch(_ s: String, _ p: String) -> Bool {
         var i = 0
    var j = 0
    var match = 0
    var star = -1
    while i < s.count {
        if j < p.count && (Array(s)[i] == Array(p)[j] || Array(p)[j] == Character("?")) {
            i+=1
            j+=1
        } else if j < p.count && Array(p)[j] == Character("*") {
            match = i
            star = j
            j+=1
        } else if star != -1 {
            j = star + 1
            match+=1
            i = match
        } else {
            return false
        }
    }
    while j < p.count && Array(p)[j] == Character("*") {j+=1}
    return j == p.count
    }
}

---

760ms

class Solution {
    func isMatch(_ s: String, _ p: String) -> Bool {
        var s = ["a"] + Array(s)
        var p = ["a"] + Array(p)
        var dp = Array(repeating:Array(repeating:false,count:p.count),count:s.count)
        dp[0][0] = true //"a" == "a"
        
        for pPos in stride(from:1,to:p.count,by:1) {
            if p[pPos] == "*" {
                dp[0][pPos] = true
            } else {
                break
            }
        }

        for sPos in stride(from:1,to:s.count,by:1) {
            for pPos in stride(from:1,to:p.count,by:1) {
                if p[pPos] == "*" {
                    dp[sPos][pPos] = dp[sPos - 1][pPos] || dp[sPos][pPos - 1]
                } else {
                    dp[sPos][pPos] = dp[sPos - 1][pPos - 1] && (s[sPos] == p[pPos] || p[pPos] == "?")
                }
                
            }
        }

        return dp[s.count - 1][p.count - 1]
    }
}