题目：
给定一个字符串 s 和一个字符串数组 words。 words 中所有字符串 长度相同。
s 中的 串联子串 是指一个包含 words 中所有字符串以任意顺序排列连接起来的子串。
- 例如，如果
words = ["ab","cd","ef"]， 那么"abcdef"，"abefcd"，"cdabef"，"cdefab"，"efabcd"， 和"efcdab"都是串联子串。"acdbef"不是串联子串，因为他不是任何words排列的连接。
返回所有串联子串在 s 中的开始索引。你可以以 任意顺序 返回答案。
题目实例：
示例 1：
输入：s = "barfoothefoobarman", words = ["foo","bar"]
输出：[0,9]
解释：因为 words.length == 2 同时 words[i].length == 3，连接的子字符串的长度必须为 6。
子串 "barfoo" 开始位置是 0。它是 words 中以 ["bar","foo"] 顺序排列的连接。
子串 "foobar" 开始位置是 9。它是 words 中以 ["foo","bar"] 顺序排列的连接。
输出顺序无关紧要。返回 [9,0] 也是可以的。
示例 2：
输入：s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
输出：[]
解释：因为 words.length == 4 并且 words[i].length == 4，所以串联子串的长度必须为 16。
s 中没有子串长度为 16 并且等于 words 的任何顺序排列的连接。
所以我们返回一个空数组。
示例 3：
输入：s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
输出：[6,9,12]
解释：因为 words.length == 3 并且 words[i].length == 3，所以串联子串的长度必须为 9。
子串 "foobarthe" 开始位置是 6。它是 words 中以 ["foo","bar","the"] 顺序排列的连接。
子串 "barthefoo" 开始位置是 9。它是 words 中以 ["bar","the","foo"] 顺序排列的连接。
子串 "thefoobar" 开始位置是 12。它是 words 中以 ["the","foo","bar"] 顺序排列的连接。
代码：
class Solution(object):
def findSubstring(self, s, words):
"""
:type s: str
:type words: List[str]
:rtype: List[int]
"""
l_word=len(words[0])
l_words=len(words)
l_s=len(s)
ans=[]
if l_s<l_word:#不符合直接返回空
return ans
strandard_dic={} #真值字典
for word in words:
if word in strandard_dic:
strandard_dic[word]+=1
else:
strandard_dic[word]=1
for i in range(l_word):
star=i #左初始指针
j=i #右遍历指针
count=0
count_dic={} #临时字典
while j+l_word<=l_s: #窗口大小为l_word长度
temp_word=s[j:j+l_word] #窗口值
if temp_word in strandard_dic: #跟真值字典值对比
count+=1 #记录当前指针内部含有WORD数目
if temp_word not in count_dic: #如果存在临时字典加1
count_dic[temp_word]=1
else:
count_dic[temp_word]+=1
while count_dic[temp_word]>strandard_dic[temp_word]: #如果当前临时字典大的话，左指针就向右，一直遍历到当前临时字典小于等于真值字典
temp_wordV2=s[star:star+l_word]
star+=l_word
count-=1
count_dic[temp_wordV2]-=1
if count==l_words:#等于的话说明正好随机匹配上，左指针向左步进一格
ans.append(star)
temp_wordV2=s[star:star+l_word]
count_dic[temp_wordV2]-=1
count-=1
star+=l_word
j+=l_word #不管如何右指针一直遍历
else: #如果不在左指针直接回来，左右指针重合
star=j+l_word
j=star
count=0
count_dic.clear()
return ans
作者：陈明义
链接：https://leetcode.cn/problems/substring-with-concatenation-of-all-words/solutions/2814617/python98-by-chen-ming-yi-4-dczm/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。代码思想：
本题设计重点在于右指针遍历，左指针跟进，同时步进窗口大小为单个word长度。
要想满足所有窗口均被遍历，则左右指针一共需要需要遍历单个word长度大小次数。
即代码的整个外循环for i in range(l_word)
代码设计：
设定左指针start，右指针j，记录真实word情况的哈希表，以及临时记录的哈希表
同时还有记录当前临时单次个数的count
所遇到的情况：
1.右指针遍历单词满足在哈希表中，count+1,然后对应临时哈希表+1
如果对应真值继续向右遍历，如果大于说明多填充，则左指针向右遍历，直至将多余剔除。
2.右指针遍历单次满足在哈希表中，count+1,然后对应临时哈希表+1，
同时count大小对应words长度，说明正好满足，左指针加入结果，然后向右步进，同时删除对应临时字典值
3.如果当前数值不满足，则说明当前遍历字符不可能满足对应随机排布，左右指针汇合，重新开始步进。
时间复杂度： 𝑂(𝑁⋅𝑀⋅𝐿)O(N⋅M⋅L)，其中 N 是字符串 s 的长度，M 是 words 的长度，L 是每个单词的长度。
我自己的代码，不如上面这个，我总结一下缺点，可以过，但是时间多个4倍：
class Solution:
def findSubstring(self, s: str, words: List[str]) -> List[int]:
numdiction={}
zhenzhizidian={}
for word in words:
zhenzhizidian[word]=zhenzhizidian.get(word,0)+1
countnum=len(words)
zilength=len(words[0])
totallength=len(s)
result=[]
tmpcount=0
tmpstr=''
count=0
if totallength<zilength*countnum:
return []
for idx in range(zilength):
numdiction.clear()
count=0
tmpcount=0
tmpstr=''
start=idx
for i in range(idx,totallength):#start开始的
tmpstr+=s[i]
count+=1
if count==zilength: #每次等于子串长度判断
numdiction[tmpstr]=numdiction.get(tmpstr,0)+1
tmpcount+=1
tmpstr=''
count=0
if tmpcount==countnum: #窗口满足数目及长度
if all(numdiction.get(word)==zhenzhizidian[word] for word in words):
result.append(start)
for j in range(start,start+zilength):
tmpstr+=s[j]
numdiction[tmpstr]-=1
tmpstr=''
tmpcount-=1
start+=zilength
return result代码思想：
设计的跟上面的代码差不多，我当时也是按照左右指针以及窗口设计，但是没有左右指针没有遍历l_word长度，导致没有遍历所有应该的窗口。主要差距在代码逻辑上。
代码逻辑：
我是每次从起始点到重点遍历，然后用临时字符串保存，将对应字符串的值加到字典里，
如果临时保存的words数目等于真实words数目，对比字典值，如果不满足，左指针步进一个窗口大小，然后右指针步进
这样设计会导致多进行很多操作，每次都要满足真实words长度都会检查
上面代码设计将左右指针步进进行了优化
重复，报错左指针就会跟进，省去了很多不必要的操作
把大窗口进行拆分小窗口，判断每个小窗口遇到的情况，当小窗口都满足时，大窗口一定满足
我的代码时间复杂度O(N⋅(N/L+M⋅L))，其中 N 是字符串 s 的长度，M 是 words 的长度，L 是每个单词的长度