【算法】Substring with Concatenation of All Words 所有单词链接而成的子串

题目

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 "barfoo" and "foobar" respectively.
The output order does not matter, returning [9,0] is fine too.
Example 2:

Input:
s = "wordgoodgoodgoodbestword",
words = ["word","good","best","word"]
Output: []

给出一个字符串 s ，和一个单词数组 words，words 中所有的单词长度相同，找出 s 中，由 words 所有单词拼接而成的子串的起始索引。

解题思路

因为 words 中所有的单词长度是相同的，所以可以考虑以固定的单词长度为切割，遍历比较每个单词：

1. 用 words 创建 map，key 为单词，value 为单词的数量。
2. s 长度 sLen，单词个数 wCount，单词长度 wLen，存储结果数组 result。
3. 由于是遍历比较单词，所以两层遍历，外层的遍历 i 是 0 到 wLen-1，里层遍历 j 为 i 到 sLen-wLen，每次增长 wLen。
4. 外层遍历：将 left 索引移动到 i ，总匹配成功单词数量 count = 0，创建单词匹配池 pairPool，key 为单词，匹配数量 value 为 0 。
5. 里层遍历：
   • 获取 s 中的单词 subStr，若匹配成功，则 pairPool 中对应匹配数量 +1，总匹配成功单词数量 +1
   • 匹配成功之后，如果 subStr 匹配成功数量大于 words 中的数量，则说明 subStr 匹配过多，需要从 left 开始逐一抛弃单词，直至subStr 匹配数量与 words 中的数量一致
   • 如果 总匹配成功单词数量 count 等于 wCount，则说明在该次比较中，words 的所有单词均匹配成功，left 即为一个结果，将 left 加入到 result中，count -1，left 右移 wLen
   • 如果 subStr 匹配失败，则抛弃之前的匹配数据，重置 pairPool、count，将left 重置到 j + wLen处
6. 两层遍历结束后，返回结果 result

代码实现

func findSubstring(_ s: String, _ words: [String]) -> [Int] {
        //如果 s 或者 words 为空，则返回 []
        if s.isEmpty || words.count<=0 {
            return []
        }
        //声明 s 长度 sLen，单词个数 wCount，单词长度 wLen
        let sLen = s.count, wCount = words.count, wLen = words.first!.count
        //声明 result 存储结果用
        var result = [Int]()
        // map 用于存储 words 中每个单词的个数
        var map = [String:Int]()
        // pairPool1 用于重新初始化匹配单词池
        var pairPool1 = [String:Int]()
        // 配置 map 和 pairPool1
        for word in words {
            if map.keys.contains(word) {
                map[word]! += 1
            }else{
                map[word] = 1
                pairPool1[word] = 0
            }
        }
        // 遍历从 0 到 wLen-1
        for i in 0 ..< wLen {
            // left 为目标子串的左索引， count 为已经匹配成功的单词个数
            var left = i, count = 0
            //将pairPool1 复制给 pairPool 进行初始化，pairPool 用以存储每个单词已经匹配的个数
            var pairPool = pairPool1
            // 从 i 开始，wlen 为长度，sLen=wLen 为尾，遍历每个单词
            for j in stride(from: i, through: sLen-wLen, by: wLen) {
                //获取 s 中 j 索引处的单词 subStr
                let jIndex = s.index(s.startIndex, offsetBy: j)
                let subStr = String(s[jIndex ..< s.index(jIndex, offsetBy: wLen)])
                //如果 words 中含有该单词，则单词匹配成功
                if map.keys.contains(subStr) {
                    //单词匹配成功，在匹配池中，subStr 的匹配数量 +1 ，总匹配数量 count +1
                    pairPool[subStr]! += 1
                    count += 1
                    //如果 s 中 subStr 匹配数量大于 words 中的数量，则从 left 开始逐一抛弃单词
                    //直至 s 中 subStr 匹配数量等于 words 中的数量
                    while pairPool[subStr]! > map[subStr]! {
                        //获取 left 索引处单词 lSubStr
                        let lIndex = s.index(s.startIndex, offsetBy: left)
                        let lSubStr = String(s[lIndex ..< s.index(lIndex, offsetBy: wLen)])
                        // lSubStr 匹配成功数量 -1
                        pairPool[lSubStr]! -= 1
                        //总匹配成功单词数量 count -1
                        count -= 1
                        // left 右移 wLen 位
                        left += wLen
                    }
                    //如果 count 等于 wCount，则说明在该次比较中，words 的所有单词均匹配成功，left 即为一个结果
                    if count == wCount {
                        // words 中所有单词匹配成功，将结果 left 添加到 result 中
                        result.append(left)
                        //获取 left 索引处单词 lSubStr
                        let lIndex = s.index(s.startIndex, offsetBy: left)
                        let lSubStr = String(s[lIndex ..< s.index(lIndex, offsetBy: wLen)])
                        // lSubStr 匹配成功数量 -1
                        pairPool[lSubStr]! -= 1
                        //总匹配成功单词数量 count -1
                        count -= 1
                        // left 右移 wLen 位
                        left += wLen
                    }
                }else{
                    //若 words 中没有该单词，则说明匹配失败，抛弃之前的匹配数据，重置 pairPool、count，将left 重置到 j + wLen处
                    pairPool = pairPool1
                    count = 0
                    left = j + wLen
                }
            }
        }
        //返回结果
        return result
    }

代码地址：https://github.com/sinianshou/EGSwiftLearning