来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/queens-that-can-attack-the-king/
一.问题描述
给定一个字符串s 和一些 长度相同 的单词 words 。找出 s 中恰好可以由 words中所有单词串联形成的子串的起始位置。
注意子串要与words 中的单词完全匹配，中间不能有其他字符 ，但不需要考虑 words 中单词串联的顺序。
示例 1：
输入：s = “barfoothefoobarman”, words = [“foo”,“bar”]
输出：[0,9]
解释：
从索引 0 和 9 开始的子串分别是 “barfoo” 和 “foobar” 。
输出的顺序不重要, [9,0] 也是有效答案。
二.解题思路分析与代码
方法一：朴素方法求解
1. 分析
对于求串联单词所有的子串，首先想到的暴力方法就是，每次都截取和words中所有单词拼接起来相同长度的串str，然后，开始比较当前str,是否是由words中的所有串拼接而成的，如果是，则记下当前的索引作为答案.
本题，由于单词的长度是一样的，所以我们可以将截取出来的str中截取出一段一段的单词，然后和words中比较是否相等。这里我们可以借用哈希表。
定义两个哈希表，一个是words的，另一个是将截取出来的字符串str中所截的一个一个等长的单词。
代码实现如下：
lass Solution {
List<Integer> res = new ArrayList<>();
public List<Integer> findSubstring(String s, String[] words) {
Map<String, Integer> map = new HashMap<>();
int len = words.length, one_len = words[0].length(), s_len = s.length();
int total_len = one_len * len;
for(String word : words){
map.put(word, map.getOrDefault(word,0) + 1);
}
// 开始的索引
for(int i = 0; i < s_len - total_len + 1; i++){
// 将和words中等长的字符串截取出来
String s_tmp = s.substring(i, i + total_len);
// 比较的map
Map<String,Integer> tmp_map = new HashMap<>();
for(int k = 0; k < total_len; k = k + one_len){
// 截取单个单词
String substr = s_tmp.substring(k,k + one_len);
// 放入到tmp_map中
tmp_map.put(substr, tmp_map.getOrDefault(substr,0) + 1);
}
// 比较是否是一样的,如果是一样的，加入到结果集中
if(map.equals(tmp_map)) res.add(i);
}
return res;
}
}
2.复杂度分析
由于遍历和比较都是线性的，所有时间复杂度是：O（N^2）。
方法二：滑动窗口
1. 分析
从第一种朴素的暴力解法的到，上述过程每次都要反复的遍历s,即每次都只能移动一个单词，后继续判断。所以，我们可以利用滑动窗口来优化这个过程。
此时，我们不在从每个s字符串的索引开始。由于words中的word都是等长的，所以将word看成是一个基本单元。每次开始索引，只需要遍历一个单词的长度，后当遍历完成后所截取的就会截取到第一种方法中的所有情况。具体看代码实现：
我们一直在s维护这所有单词长度总和的一个长度队列！
class Solution {
List<Integer> res = new ArrayList<>();
public List<Integer> findSubstring(String s, String[] words) {
int one_word_len = words[0].length(), word_len = words.length;
Map<String, Integer> map = new HashMap<>();
for(String w: words){
map.put(w, map.getOrDefault(w,0) + 1);
}
for(int i = 0; i < one_word_len; i++){
// 定义一个count表征当前窗口的size
int left = i, right = i,count = 0;
// 定义一个窗口
Map<String,Integer> window = new HashMap<>();
while(right <= s.length() - one_word_len){
String w = s.substring(right, right + one_word_len);
window.put(w, window.getOrDefault(w,0) + 1);
// right移动
right += one_word_len;
count++;
// 当前窗口左移操作
while(window.getOrDefault(w,0) > map.getOrDefault(w,0)){
String tmp_w = s.substring(left, left + one_word_len);
window.put(tmp_w, window.getOrDefault(tmp_w, 0) - 1);
count--;
// left移动
left += one_word_len;
}
if( count == word_len) res.add(left);
}
}
return res;
}
}
2. 复杂度分析
时间复杂度：O(N ) ，
准确的来说，应该是
O(N*M)``M是单个单词的长度,但是，M最大值只有5000，我们近视忽略。
方法三：滑动窗口优化
1.分析
发现，对于上述的滑动窗口方法，如果是在窗口中出现了一个words中从来没出现的单词，方法二还是会继续的，缓慢的移动窗口。所以，在优化方面，我们就可以在碰到一个在words中从来没出现过的单词时，整个窗口都跳过当前的单词.
按照当前的分析，其实优化的代码也很简单。 代码如下：
class Solution {
List<Integer> res = new ArrayList<>();
public List<Integer> findSubstring(String s, String[] words) {
Map<String, Integer> map = new HashMap<>();
int len = words.length, one_len = words[0].length(), s_len = s.length();
int total_len = one_len * len;
for(String word : words){
map.put(word, map.getOrDefault(word,0) + 1);
}
// 开始的索引
for(int i = 0; i < s_len - total_len + 1; i++){
// 将和words中等长的字符串截取出来
String s_tmp = s.substring(i, i + total_len);
// 比较的map
Map<String,Integer> tmp_map = new HashMap<>();
for(int k = 0; k < total_len; k = k + one_len){
// 截取单个单词
String substr = s_tmp.substring(k,k + one_len);
// 放入到tmp_map中
tmp_map.put(substr, tmp_map.getOrDefault(substr,0) + 1);
}
// 比较是否是一样的
if(map.equals(tmp_map)) res.add(i);
}
return res;
}
}
2.复杂度分析
时间复杂度和方法二一样，都认为是O(N).
三. 总结
还有许多其他的方法解决这道题，本篇文章的思路较为简单。