30. 串联所有单词的子串

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

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

 

示例 1：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/substring-with-concatenation-of-all-words

题解：

考虑将所有子串做全排列然后在和字符串s对比的话，时间复杂度上就过不了，而且题目说和串联的顺序无关，那么解法应该不考虑顺序了。

考虑滑动窗口+hash

1 记录words中的单词出现次数，count_word_dic存储每个关键字出现的次数

2 如果查询当前单词出现的次数等于words里某个单词的次数，那么窗口右侧向右移一个单词的距离，计数，如果计数等于words的元素个数==所有单词都出现了一遍，记下左侧窗口的下标为首次出现的位置。

3 如果出现一个单词是words里没有的，那么根据题目，计数又从零开始，左侧窗口的下标移动到右侧窗口的下标，清空之前的记录。

4 如果某个单词出现的次数大于words中标记的次数，说明这个单词多记了，那么前面记录的也不能要了，窗口左侧向右滑动，直到这个单词被记录次数等于words中标记的次数。

滑动窗口的移动考虑以每个单词为长度向前滑动，潜台词：每个关键字的长度都是一样的。

class Solution:
    def findSubstring(self, s: str, words: List[str]) -> List[int]:
        l_word = len(words[0])
        l_s = len(s)
        l_words = len(words)
        if not s or not words:
            return []

        count_word_dic = defaultdict(int)
#1
        for i in words:
            count_word_dic[i] += 1
        
        re = []
        for  i in range(l_word):
            l,r = i ,i 
            count_w = 0
            check_word_dic = defaultdict(int)

            while r+l_word<= l_s:

                w = s[r:r+l_word]
                r += l_word
                #情况3
                if w not in words:
                    l =r
                    check_word_dic.clear()
                    count_w = 0
                else:
                    check_word_dic[w ] += 1
                    count_w += 1
                    #情况4
                    while check_word_dic[w ] > count_word_dic[w]:
                        w_=s[l:l+l_word]
                        l = l+l_word
                        check_word_dic[w_] -= 1
                        count_w -= 1
                    # 情况2
                    if count_w == l_words:
                        re.append(l)
        return re