[Swift]LeetCode76. 最小覆盖子串 | Minimum Window Substring

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

Given a string S and a string T, find the minimum window in S which will contain all the characters in T in complexity O(n).

Example:

Input: S = "ADOBECODEBANC", T = "ABC"
Output: "BANC"

Note:

• If there is no such window in S that covers all characters in T, return the empty string "".
• If there is such window, you are guaranteed that there will always be only one unique minimum window in S.

---

 给定一个字符串 S 和一个字符串 T，请在 S 中找出包含 T 所有字母的最小子串。

示例：

输入: S = "ADOBECODEBANC", T = "ABC"
输出: "BANC"

说明：

• 如果 S 中不存这样的子串，则返回空字符串 ""。
• 如果 S 中存在这样的子串，我们保证它是唯一的答案。

---

40ms

class Solution {
//initialize two pointers- left and right and initialize both to the first element of string s.
//In any sliding window problem, we have two pointers. One right pointer whose job is to expand the current
//window and the left pointer whose hob is to contract the given window. At any point, only one of those pointers
//move and the other stay fixed.

func minWindow(_ s: String, _ t: String) -> String {
    //convert the strings to character array
    //the map is necessary to convert uint8 to Int
    let schars = Array(s.utf8).map {Int($0)}
    let tchars = Array(t.utf8).map {Int($0)}
    
    
    //create hashmap
    var hash = Array(repeating: 0, count: 128)
    
    for tchar in tchars {
        hash[tchar] += 1
    }
    
    var count = tchars.count
    var start = 0
    var left = 0
    var right = 0
    var length = Int.max
    
    //We use the right pointer to expand the window until we get a desirable window i.e. a window that contains all of the characters of
    // t
    while right < schars.count {
        //if this character from schars is present in hash (i.e. in tchars), decrement count and also the count for that char in the hash by 1.
        if hash[schars[right]] > 0 {
            count -= 1
        }
        hash[schars[right]] -= 1
        right += 1
        
        while count == 0 {
            if right - left < length {
                //keep updating the length value
                length = right - left
                start = left
            }
            //Once we have a window with all the characters, we can move the left pointer ahead one by one. If the window is still a desirable one we keep //updating the minimum window size.
            if hash[schars[left]] == 0 {
                count += 1
            }
            hash[schars[left]] += 1
            left += 1
        }
    }
    
    //not present
    if length > schars.count {
        return ""
    }
    
    let index1 = s.index(s.startIndex, offsetBy: start)
    let index2 = s.index(s.startIndex, offsetBy: start + length)
    
    return String(s[index1..<index2])
  }
}

---

44ms

class Solution {
    func minWindow(_ s: String, _ t: String) -> String {
    
        let tt = Array(t.utf16).map { Int($0) }
        let ss = Array(s.utf16).map { Int($0) }
        // create hashmap
        var hash = [Int](repeating: 0, count: 128)
        for n in tt {
            hash[n] += 1
        }

        var count = tt.count, start = 0, l = 0, r = 0, length = Int.max

        while r < ss.count {
            if hash[ss[r]] > 0 {
                count -= 1
            }
            hash[ss[r]] -= 1
            r += 1
            while count == 0 {
                if r - l < length {
                    length = r - l
                    start = l
                }
                if hash[ss[l]] == 0 {
                    count += 1
                }
                hash[ss[l]] += 1
                l += 1
            }
        }

        if length > ss.count {
            return ""
        }

        let index1 = s.index(s.startIndex, offsetBy: start)
        let index2 = s.index(s.startIndex, offsetBy: start + length)
        return s.substring(with: index1..<index2)
    }
}

---

48ms

class Solution {
    func minWindow(_ s: String, _ t: String) -> String {
        let ss = Array(s.utf8).map(Int.init)
        let tt = Array(t.utf8).map(Int.init)
        var counts = [Int](repeating: 0, count: 256)
        for char in tt {
            counts[char] += 1
        }
        var left = 0
        var size = t.count
        var res = (-1, -1)
        var minL = Int.max
        for right in 0..<s.count {
            counts[ss[right]] -= 1
            if counts[ss[right]] >= 0 {
                size -= 1
            }
            
            if size == 0 {
                inner: while left < right {
                    counts[ss[left]] += 1
                    if counts[ss[left]] > 0 {
                        size += 1
                        break inner
                    }
                    left += 1
                }
                if right - left + 1 < minL {
                    minL = right - left + 1
                    res = (left, right)
                }
                left += 1
            }
        }
        if res == (-1, -1) { return "" }
        let arr = ss[res.0...res.1]
        return String(arr.map { Character(UnicodeScalar($0)!) } )
    }
}

---

Runtime: 52 ms

Memory Usage: 20.3 MB

class Solution {
    func minWindow(_ s: String, _ t: String) -> String {
        var counter:Int = 0
        var minlen:Int = Int.max
        var begin:Int = 0
        var end:Int = 0
        var head:Int = 0
        var m:[Int] = [Int](repeating:0,count:128)
        counter = t.count
        var arrT:[Int] = Array(t).map{$0.ascii}
        for c in arrT
        {
            m[c]++
        }
        var arrS:[Int] = Array(s).map{$0.ascii}
        while(end < arrS.count)
        {
            if m[arrS[end++]]-- > 0
            {
                counter--
            }
            while(counter==0)
            {
                if minlen > end - begin
                {
                    head = begin
                    minlen = end - (head)
                }
                if m[arrS[begin++]]++ == 0
                {
                    counter++
                }
            }            
        }
        let str:String = (minlen == Int.max) ? "" :s.subString(head,minlen)
        return str
        
    }
}

/*扩展Int类，实现自增++、自减--运算符*/
extension Int{
    //后缀++:先执行表达式后再自增
    static postfix func ++(num:inout Int) -> Int {
        //输入输出参数num
        let temp = num
        //num加1
        num += 1
        //返回加1前的数值
        return temp
    }
    //后缀--:先执行表达式后再自减
    static postfix func --(num:inout Int) -> Int {
        //输入输出参数num
        let temp = num
        //num减1
        num -= 1
         //返回减1前的数值
        return temp
    }
}


//Character扩展方法  
extension Character  
{  
  //属性：ASCII整数值(定义小写为整数值)
   var ascii: Int {
        get {
            let s = String(self).unicodeScalars
            return Int(s[s.startIndex].value)
        }
    }
}

extension String {
    
    // 截取字符串：指定索引和字符数
    // - begin: 开始截取处索引
    // - count: 截取的字符数量
    func subString(_ begin:Int,_ count:Int) -> String {
        let start = self.index(self.startIndex, offsetBy: max(0, begin))
        let end = self.index(self.startIndex, offsetBy:  min(self.count, begin + count))
        return String(self[start..<end]) 
    }
}

---

52ms

class Solution {
    func minWindow(_ s: String, _ t: String) -> String {
        var chs = Array(s)
        let s = s.map { letterIndex($0) }
        let t = t.map { letterIndex($0) }
        var map = [Int](repeating:0, count:256)
        for ch in t {
            map[ch] += 1
        }
        var minLen = Int.max, count = t.count
        var j = 0, startIndex = 0
        for i in 0..<s.count {
            while j < s.count && count > 0 {
                if map[s[j]] > 0 {
                    count -= 1
                }
                map[s[j]] -= 1
                j += 1
            }
            if count == 0 && j - i < minLen{
                minLen = j - i
                startIndex = i
            }
            if map[s[i]] >= 0 {
                count += 1 
            }
            map[s[i]] += 1
        }
        return minLen == Int.max ? "" : String(chs[startIndex..<(startIndex+minLen)])
    }
    
    func letterIndex(_ letter: Character) -> Int {
        return Int(letter.unicodeScalars.first!.value)
    }
}

---

72ms

class Solution {
    func minWindow(_ s: String, _ t: String) -> String {
        var map = [Character : Int]()   //t's char and count
        var diff = t.count 
        var left = 0
        var right = 0
        // var res = ""
        var len = Int.max
        var start = 0
        let sArr = Array(s)
        for char in t {
            map[char, default: 0 ] += 1   // count
        }

        while right < sArr.count {
            let char = sArr[right]
            
            if let count = map[char] {  //t has this char
                if count > 0 {          //this is useful to diff
                    diff -= 1
                }
                map[char] = count - 1
            }
            if diff == 0 {  // found an ans
                while left <= right{
                    if let count = map[sArr[left]] {
                        if count == 0 {
                            if right - left + 1 < len{
                                len = right - left + 1 
                                start = left
                            }
                            map[sArr[left]] = count + 1
                            left += 1
                            diff += 1
                            break
                        }
                        map[sArr[left]] = count + 1
                    }
                    left += 1
                } 
            }
    
            right += 1
        }
        if len == Int.max { return "" }
        //              print(start)
        //              print(len)
        return String(sArr[start ..< start + len])
    }
}

---

76ms

class Solution {
    func minWindow(_ s: String, _ t: String) -> String {
        guard s.count>=t.count else {return ""}
        
        var dic = [String.Element:Int]()
        let sChars = Array(s)
        let tChars = Array(t)
        
        for char in tChars {
            if let val = dic[char] {
                dic[char] = val+1
            } else {
                dic[char] = 1
            }
        }
        
        var start = 0
        var minStart = 0, minLength = Int.max
        var numOfTargets = t.count
        
        for end in 0..<sChars.count {

            if let curOcurrance = dic[sChars[end]] {
                if curOcurrance > 0 {
                    numOfTargets -= 1
                }
                dic[sChars[end]] = curOcurrance-1
            }

            while numOfTargets == 0 {
                if minLength > end-start+1 {
                    minLength = end-start+1
                    minStart = start
                }
                
                if let curOccurance = dic[sChars[start]] {
                    if curOccurance == 0 {
                        numOfTargets += 1
                    }
                    dic[sChars[start]] = curOccurance+1
                }
                start+=1
            }
        }

        return minLength == Int.max ? "" : String(sChars[minStart..<minStart+minLength])
    }
}

---

84ms

class Solution {
    func minWindow(_ s: String, _ t: String) -> String {
        var len = Int.max
        var count = t.count
        var result = ""
        
        var dict: [Character: Int] = [:]
        for c in t {
            dict[c, default: 0] += 1
        }
        
        var i = 0, start = 0
        var startIndex = s.startIndex, iIndex = s.startIndex
        
        while iIndex < s.endIndex {
            let c = s[iIndex]
            
            if let cnt = dict[c] {
                dict[c] = cnt - 1
                
                if cnt >= 1 {
                    count -= 1    
                }
            }
            
            while count == 0 && start <= i {
                if i - start + 1 < len {
                    len = i - start + 1
                    result = String(s[startIndex...iIndex])
                }
                
                let startChar = s[startIndex]
                if let cnt = dict[startChar] {
                    dict[startChar] = cnt + 1
                    
                    if cnt >= 0 {
                        count += 1    
                    }
                }
                start += 1
                startIndex = s.index(after: startIndex)
            }
            
            iIndex = s.index(after: iIndex)
            i += 1
        }
        
        return result
    }
}

---

88ms

class Solution {
    func minWindow(_ s: String, _ t: String) -> String {
        
        if s == t {
            return s
        }
        var charMap : [Character: Int] = [:]
        var charMap2 : [Character: Int] = [:]
        for ch in t {
            if let val = charMap[ch] {
                charMap[ch] = val + 1
            } else {
                charMap[ch] = 1
            }
            charMap2[ch] = 0
        }
        let sCount = s.length
        var sChar = Array(s)
        var lPtr = 0
        var rPtr = 0
        var resultLeft = 0
        var resultRight = 0
        let tCount = t.length
        var currentCount = 0
        var found = false

        while rPtr < sCount {
            if let rVal = charMap2[sChar[rPtr]]   {
                charMap2[sChar[rPtr]] = rVal + 1
                if let val = charMap[sChar[rPtr]], rVal < val {
                    currentCount += 1
                }
            }
            
            if currentCount == tCount {
                if (resultLeft == 0 && resultRight == 0) || (resultRight - resultLeft > rPtr - lPtr) {
                    resultLeft = lPtr
                    resultRight = rPtr
                    found = true
                }
                while lPtr < sCount {
                    if let lVal = charMap2[sChar[lPtr]] {
                        charMap2[sChar[lPtr]] = lVal - 1
                        if let val = charMap[sChar[lPtr]] {
                            if lVal == val {
                                currentCount -= 1
                                if (resultRight - resultLeft > rPtr - lPtr) {
                                    resultLeft = lPtr
                                    resultRight = rPtr
                                }
                                lPtr += 1
                                break
                            }
                        }
                    }
                    lPtr += 1
                }
            }
            rPtr += 1
        }
        
        if found {
            let indexLeft = s.index(s.startIndex, offsetBy: resultLeft)
            let indexRight = s.index(s.startIndex, offsetBy: resultRight)
            return String(s[indexLeft...indexRight])
        }
        
        return ""
    }
}

---

20024 kb 

class Solution {
    func minWindow(_ s: String, _ t: String) -> String {
        guard !s.isEmpty && !t.isEmpty else { 
            return ""
        }
        
        var wordLetters = [Character: Int]()
        
        for symb in t {
            let count = wordLetters[symb] ?? 0
            wordLetters[symb] = count + 1
        }
        
        var visitedCharacters = [Character: Int]()
        
        let string = Array(s)
        
        var left = 0
        var right = 0
        
        var bestWindow: ArraySlice<Character>? 
        
        while right < string.count {
            let letter = string[right]
            right += 1
            
            let count = visitedCharacters[letter] ?? 0
            visitedCharacters[letter] = count + 1
            
            var validWindow = true
            
            for (key, count) in wordLetters {
                let visitedCount = visitedCharacters[key] ?? 0
                if visitedCount < count {
                    validWindow = false
                    break
                } 
            }
            
            while validWindow {
                if (bestWindow?.count ?? Int.max) > right - left {
                    bestWindow = string[left..<right]
                }
                let sCount = visitedCharacters[string[left]] ?? 1
                visitedCharacters[string[left]] = sCount - 1
                left += 1
                
                for (key, count) in wordLetters {
                    let visitedCount = visitedCharacters[key] ?? 0
                    if visitedCount < count {
                        validWindow = false
                        break
                    } 
                }
                
            }
        }
        
        guard let window = bestWindow else { return "" }
        return String(window)
    }
}

---

20052 kb

class Solution {
    func minWindow(_ s: String, _ t: String) -> String {
        var counts = [Character:Int]()
        for char in t {
            let count = counts[char, default: 0]
            counts[char] = count + 1
        }
        var counter = counts.count
        var left = 0
        var right = 0
        var result = ""
        var length = Int.max
        let s = Array(s)
        while right < s.count {
            if let count = counts[s[right]] {
                counts[s[right]] = count - 1
                if count - 1 == 0 {
                    counter -= 1
                }
            }
            right += 1
            while counter == 0 {
                if right - left < length {
                    length = right - left
                    result = String(s[left..<right])
                }
                if let count = counts[s[left]] {
                    counts[s[left]] = count + 1
                    if count + 1 == 1 {
                        counter += 1
                    }
                }
                left += 1
            }
        }
        
        return result
    }
}

---

20124 kb

class Solution {
    func minWindow(_ s: String, _ t: String) -> String {
        guard !s.isEmpty && !t.isEmpty else { 
            return ""
        }
        
        var wordLetters = [Character: Int]()
        
        var formed = 0
        
        for symb in t {
            let count = wordLetters[symb] ?? 0
            wordLetters[symb] = count + 1
        }
        let required = wordLetters.count
        
        var visitedCharacters = [Character: Int]()
        
        let string = Array(s)
        
        var left = 0
        var right = 0
        
        var bL = 0
        var bR = Int.max
        
        while right < string.count {
            let letter = string[right]
            right += 1
            
            let count = visitedCharacters[letter] ?? 0
            visitedCharacters[letter] = count + 1
            
            if (wordLetters[letter] ?? 0) != 0 && wordLetters[letter] == visitedCharacters[letter] {
                formed += 1
            }

            
            while formed == required {
                if (bR - bL) > right - left {
                    bR = right
                    bL = left
                }
                let letter = string[left]
                let sCount = (visitedCharacters[letter] ?? 1) - 1
                visitedCharacters[letter] = sCount
                
                if let wordCount = wordLetters[letter], 
                    wordCount > sCount {
                        formed -= 1
                    }
                left += 1
                
            }
        }
        
        guard bR < Int.max else { return "" }
        return String(string[bL..<bR])
    }
}