[Swift]LeetCode30. 与所有单词相关联的字串 | Substring with Concatenation of All Words

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

You are given a string, s, and a list of words, words, that are all of the same length. Find all starting indices of substring(s) in s that is a concatenation of each word in words exactly once and without any intervening characters.

Example 1:

Input:
  s = "barfoothefoobarman",
  words = ["foo","bar"]
Output: [0,9]
Explanation: Substrings starting at index 0 and 9 are "barfoor" and "foobar" respectively.
The output order does not matter, returning [9,0] is fine too.

Example 2:

Input:
  s = "wordgoodstudentgoodword",
  words = ["word","student"]
Output: []

---

给定一个字符串 s 和一些长度相同的单词 words。在 s 中找出可以恰好串联 words 中所有单词的子串的起始位置。

注意子串要与 words 中的单词完全匹配，中间不能有其他字符，但不需要考虑 words 中单词串联的顺序。

示例 1:

输入:
  s = "barfoothefoobarman",
  words = ["foo","bar"]
输出: [0,9]
解释: 从索引 0 和 9 开始的子串分别是 "barfoor" 和 "foobar" 。
输出的顺序不重要, [9,0] 也是有效答案。

示例 2:

输入:
  s = "wordgoodstudentgoodword",
  words = ["word","student"]
输出: []

---

304ms

class Solution {
    func findSubstring(_ s: String, _ words: [String]) -> [Int] {
        guard !words.isEmpty else {
            return []
        }
        guard !s.isEmpty else {
            return words.contains("") ? [0] : []
        }
        
        let string = Array(s)
        let wordLength = words[0].count
        let totalWordLength = words.count * wordLength
        
        guard totalWordLength <= string.count else {
            return []
        }
        
        let originalWordToCount = words.reduce(into: [:], { $0[$1, default:0] += 1 })
        
        var startingIndices: [Int] = []
        
        for i in 0..<wordLength {
            
            var startIndex = i
            var wordToCount = originalWordToCount
            
            for j in stride(from: i, to: string.count-wordLength+1, by: wordLength) {
                
                let word = String(string[j..<(j+wordLength)])
                
                if let originalCount = originalWordToCount[word] {
                    
                    while wordToCount[word] == nil {
                        let startWord = String(string[startIndex..<(startIndex+wordLength)])
                        wordToCount[startWord, default: 0] += 1
                        startIndex += wordLength
                    }
                    
                    if let currentCount = wordToCount[word] {
                        if currentCount == 1 {
                            wordToCount[word] = nil 
                        } else {
                            wordToCount[word] = currentCount - 1
                        }
                    }
                    
                    if wordToCount.isEmpty {
                        startingIndices.append(startIndex)
                        
                         let startWord = String(string[startIndex..<(startIndex+wordLength)])
                        wordToCount[startWord, default: 0] += 1
                        startIndex += wordLength
                    }
                    
                } else {
                    // reset 
                    startIndex = j+wordLength
                    wordToCount = originalWordToCount
                }
            }
        }
        
        return startingIndices
    }
}

---

312ms

class Solution {
    func findSubstring(_ s: String, _ words: [String]) -> [Int] {
        guard !words.isEmpty else {
            return []
        }
        guard !s.isEmpty else {
            return words.contains("") ? [0] : []
        }
        
        let string = Array(s)
        
        let wordLength = words[0].count
        let totalWordLength = words.count * wordLength
        
        guard string.count >= totalWordLength else {
            return []
        }
        
        let originalWordToCount = words.reduce(into: [:], { $0[$1, default: 0] += 1 })
        
        var startingIndices: [Int] = []
        
        for i in 0..<wordLength {

            var startIndex = i
            var wordToCount: [String:Int] = [:]
            var wordCount = 0
            
            for j in stride(from: i, to: string.count - wordLength + 1, by: wordLength) {
                
                let word = String(string[j..<(j+wordLength)])
                
                if let originalCount = originalWordToCount[word] {
                    
                    wordToCount[word, default: 0] += 1
                    wordCount += 1
                    
                    while let count = wordToCount[word], count > originalCount {
                        let startWord = String(string[startIndex..<(startIndex+wordLength)])
                        wordCount -= 1
                        wordToCount[startWord, default: 1] -= 1
                        startIndex += wordLength
                    }
                    
                    if wordCount == words.count {
                        startingIndices.append(startIndex)
                        
                        let startWord = String(string[startIndex..<(startIndex+wordLength)])
                        wordCount -= 1
                        wordToCount[startWord, default: 1] -= 1
                        startIndex += wordLength
                    }
                    
                } else {
                    // reset
                    startIndex = j+wordLength
                    wordToCount = [:]
                    wordCount = 0
                }
            }
        }
        
        return startingIndices
    }
}

---

424ms

class Solution {
    func findSubstring(_ s: String, _ words: [String]) -> [Int] {
        
        guard !words.isEmpty else {
            return []
        }
        guard !s.isEmpty else {
            return words.contains(s) ? [0] : []
        }
        
        let string = Array(s)
        let wordLength = words[0].count
        let totalWordLength = wordLength * words.count
        
        guard totalWordLength <= string.count else {
            return []
        }
        
        let originalWordToCount = words.reduce(into: [:], { $0[$1, default: 0] += 1 })
        
        var startingIndices: [Int] = []
        
        for i in 0..<wordLength {
            
            var startIndex = i
            var currentWordToCount = originalWordToCount
            
            for j in stride(from: i, to: string.count-wordLength+1, by: wordLength) {
                
                let word = String(string[j..<(j+wordLength)])
                
                if let originalCount = originalWordToCount[word] {
                    
                    while currentWordToCount[word] == nil {
                        let startWord = String(string[startIndex..<(startIndex+wordLength)])
                        startIndex += wordLength
                        currentWordToCount[startWord, default: 0] += 1
                    }
                    
                    if let currentCount = currentWordToCount[word] {
                        if currentCount == 1 {
                            currentWordToCount[word] = nil
                        } else {
                            currentWordToCount[word] = currentCount-1
                        }
                    }
                    
                    if currentWordToCount.isEmpty {
                        startingIndices.append(startIndex)
                        
                        // get a new combination
                        let startWord = String(string[startIndex..<(startIndex+wordLength)])
                        startIndex += wordLength
                        currentWordToCount[startWord] = 1
                    }
                    
                } else {
                    // reset
                    startIndex = j+wordLength
                    currentWordToCount = originalWordToCount
                }
            }
        }
        
        return startingIndices
    }
}

---

1128ms

class Solution {
    func findSubstring(_ s: String, _ words: [String]) -> [Int] {
        if words.isEmpty {
            return []
        }
        let wordLen = words[0].count
        let substrLen = words.count * wordLen
        
        if s.count <  substrLen {
            return []
        }

        var answer = [Int]()
        answer.reserveCapacity(s.count)

        var dict = [String:Int]()
        for w in words {
            var count = 1
            if let v = dict[w] {
                count = count + v
            }
            dict[w] = count
        }
        
        var i = s.startIndex
        let end = s.index(s.endIndex, offsetBy: -substrLen)
        while i <= end {
            if isSubstring(s[i..<s.index(i, offsetBy:substrLen)], dict, wordLen) {
                answer.append(s.distance(from: s.startIndex, to: i))
            }
            i = s.index(after: i)
        }
        return answer
    }
    
    func isSubstring(_ s: Substring, _ words: [String:Int], _ wordLen: Int) -> Bool {
        var d = words
        var substr = s
        while !substr.isEmpty {
            let w = String(substr[substr.startIndex..<substr.index(substr.startIndex, offsetBy: wordLen)])
            if let c = d[w], c > 0 {
                d[w] = c - 1
            } else {
                return false
            }
            substr = substr[substr.index(substr.startIndex, offsetBy: wordLen)...]
        }
        return true
    }
}

---

1852ms

class Solution {
    func findSubstring(_ s: String, _ words: [String]) -> [Int] {
        if s == nil || words.count == 0 {
            return []
        }
        var result: [Int] = []
        var dict1: [String: Int] = [String: Int]()
        var dict2: [String: Int] = [String: Int]()
        let stringLength: Int = s.count
        let wordsListSize: Int = words.count
        let wordLength: Int = words[0].count
        for i in 0 ..< wordsListSize {
            if dict1[words[i]] == nil {
                dict1[words[i]] = 1
            } else {
                dict1[words[i]]! += 1
            }
        }
        var s1: String
        var s2: String
        var counter1: Int
        var counter2: Int
        for i in 0 ..< wordLength {
            counter1 = 0
            counter2 = i
            var j = i;
            while j < stringLength {
                s1 = s[j..<j+wordLength]
                if dict1[s1] == nil {
                    dict2.removeAll(keepingCapacity: false)
                    counter1 = 0
                    counter2 = j + wordLength
                } else if dict2[s1] == nil || dict2[s1]! < dict1[s1]! {
                    if dict2[s1] == nil {
                        dict2[s1] = 1
                    } else {
                        dict2[s1]! += 1
                    }
                    counter1 += 1
                } else {
                    s2 = s[counter2..<counter2+wordLength]
                    while s2 != s1 {
                        dict2[s2]! -= 1
                        counter1 -= 1
                        counter2 += wordLength
                        s2 = s[counter2..<counter2+wordLength]
                    }
                    counter2 += wordLength
                }
                if counter1 == wordsListSize {
                    result.append(counter2)
                    s2 = s[counter2..<counter2+wordLength]
                    dict2[s2]! -= 1
                    counter1 -= 1
                    counter2 += wordLength
                }
                j += wordLength
            }
            dict2.removeAll(keepingCapacity: false)
        }
        return result
    }
}

private extension String {
    subscript (range: Range<Int>) -> String {
        guard let localEndIndex = self.index(self.startIndex, offsetBy: range.upperBound, limitedBy: self.endIndex) else {
            return String(self[self.index(self.startIndex, offsetBy: range.lowerBound)..<self.endIndex])
        }
        return String(self[self.index(self.startIndex, offsetBy: range.lowerBound)..<localEndIndex])
    }
}

---

3192ms

class Solution {
    func findSubstring(_ s: String, _ words: [String]) -> [Int] {
        if words.count == 0 { return [] }
        let len = words[0].count
        
        let s = Array(s.characters)
        let concatLen = len * words.count
        
        if s.count < concatLen { return [] }
        
        // Map word to count
        var dict = [String: Int]()
        for i in 0..<words.count {
            let count = (dict[words[i]] ?? 0) + 1
            dict[words[i]] = count
        }
        
        var res = [Int]()
        for i in 0..<(s.count-words.count*len+1) {
            var track = [String: Int]()
            var ok = true
            let startSequence = (0..<words.count).map { i + $0 * len }
            for start in startSequence {
                let substring = String(s[start..<start+len])
                let count = (track[substring] ?? 0) + 1
                if count > (dict[substring] ?? 0) {
                    ok = false
                    break
                }
                track[substring] = count
            }
            
            if ok {
                res.append(i)
            }
        }
        
        return res
    }
}

---

3480ms

class Solution {
    func findSubstring(_ s: String, _ words: [String]) -> [Int] {
        guard s.count > 0 && words.count > 0 else {
        return []
    }
    
    var counts = [String: Int]()
    words.forEach { word in
        counts[word, default: 0] += 1
    }
    
    var indices = [Int]()
    let ss = s.utf8CString
    let n = s.count
    let wc = words.count
    let len = words.first!.count
    for i in 0..<(n - wc * len + 1) {
        var seen = [String: Int]()
        var j = 0
        while j < wc {
            let cs = Array(ss[(i + j * len)..<(i + (j + 1) * len)]) + [0]
            let word = String(cString: cs)
            if words.contains(word) {
                seen[word, default: 0] += 1
                if seen[word]! > counts[word]! {
                    break
                }
            } else {
                break
            }
            j += 1
        }
        
        if j == wc {
            indices.append(i)
        }
    }
    return indices
    }
}

---

3556ms

 class Solution {
    func findSubstring(_ s: String, _ words: [String]) -> [Int] {
        var results:[Int] = []
        if s == nil || s.isEmpty || words == nil || words.isEmpty {return results}
        var h:[String: Int] = [String: Int]()
        for word in words
        {
            if h[word] == nil
            {
                h[word] = 1
            }
            else
            {
                h[word] = h[word]! + 1
            }
        }
        var len:Int = words[0].count
        for offset in 0..<len
        {
            var f:[String: Int] = [String: Int]()
            var from:Int = offset
            var count:Int = 0
            for i in stride(from: offset,through:s.count - len,by: len)
            {
                var word:String = s.subString(i,len)
                var hc:Int? = h[word]
                if hc == nil
                {
                    from = i + len
                    count = 0
                    f = [String: Int]()
                    continue
                }
                var fc:Int? = f[word]
                if fc == nil
                {
                    fc = 1
                }
                else
                {
                    fc = fc! + 1
                }
                f[word] = fc
                count += 1
                while (fc! > hc!)
                {
                    var fword = s.subString(from,len)
                    f[fword] = f[fword]! - 1
                    fc = f[word]!
                    from += len
                    count -= 1
                }
                if count == words.count
                {
                   results.append(from)
                }
            }
        }
        return results
    }
}

extension String {
    // 截取字符串：指定区间
    // - Parameter range: 闭区间
    // - Returns: 子字符串
    func subString(_ begin:Int,_ count:Int) -> String {
        let start = self.index(self.startIndex, offsetBy: begin)
        let end = self.index(self.startIndex, offsetBy: begin + count - 1)
        return String(self[start...end]) 
    }
}