30. 串联所有单词的子串【 力扣(LeetCode) 】

一、题目描述

给定一个字符串 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"] 顺序排列的连接。

提示：

1 <= s.length <= 104
1 <= words.length <= 5000
1 <= words[i].length <= 30
words[i] 和 s 由小写英文字母组成

三、解题思路

1. 基本思路：
     多层滑动窗口
2. 具体思路：
   • 定义：ans 用于存放答案；use 用于存放 words 中单词出现的频率；use_temp 表示在每一层滑动窗口中初始的单词频率，初始化为 use ；len 表示每个单词长度；c 表示单词数量；n 表示字符串长度
   • 遍历层数：第 i 层表示从 i 个字符开始，由 len 个字符组成的单词序列，小于 len 长度则舍弃。【例如 len=3，字符串为 "abcdefghij" ，则第 1 层表示 bcd 、efg 和 hij 三个单词，第 2 层表示 cde 和 fgh 两个单词】
   • 每层的滑动窗口：定义变量 start 和 end 表示首单词和尾单词。每次变量该层的单词序列，在滑动窗口的尾部加入一个单词，判断该单词是否还有剩余的频率，有则频率 -1 ，如果为 0 ，则删去 ；没有则滑动窗口从头部开始舍弃单词，每舍弃一个单词，该单词频率 +1 ，一直丢弃到 尾部单词有空位 或 者滑动窗口为空 为止。一旦每层的单词频率 use_temp 为空，则表示所有单词都用到了，则把首单词的下标加入到答案中。
     【 use_temp 为空可以保证滑动窗口内所有单词都是由 words 的单词组成的，证明：如果不是，那么存在两种情况，一是出现了 words 里面没有出现的单词，二是出现了 words 里面有的单词，但是频率超了；
     • 对于第一种情况来说：出现了不存在的单词，use_temp 里面没有该单词的频率，就会进行从头部舍弃单词，一直舍弃到该单词有空位，而该单词有空位的情况是不可能满足的，所以会一直舍弃到滑动窗口为空为止，所以该单词也会被舍弃。
     • 对于第二种情况来说，一旦频率不够，就会进行舍弃，所以不可能会出现滑动窗口里面的单词频率超过的可能。】
   • 返回结果 ans 。

四、参考代码

时间复杂度：$\mathrm{O}(n\ast len)$ 字符串长度 * 层数
空间复杂度：$\mathrm{O}(c\ast len)$ map 的空间

class Solution {
public:
    map<string, int> init(vector<string> words) {
        int n = words.size();
        map<string, int> ans;

        for (int i = 0; i < n; i++) 
                ans[words[i]]++;

        return ans;
    }
    
    vector<int> findSubstring(string s, vector<string>& words) {
        int n = s.length();
        int c = words.size(), len = words[0].length();
        vector<int> ans;
        map<string, int> use = init(words);

        for (int i = 0; i < len; i++) {
            map<string, int> use_temp = use;

            for (int j = i, k = i; k < n;) {
                string end = s.substr(k, len);
                string start = s.substr(j, len);

                if (use_temp.count(end) == 1) {
                    use_temp[end]--;
                    if (use_temp[end] == 0)
                        use_temp.erase(end);
                    k += len;
                } else {
                    while (start != end && j <= k) {
                        use_temp[start]++;
                        start = s.substr(j += len, len);
                    }
                    j += len;
                    k += len;
                }

                if (use_temp.empty()) {
                    ans.push_back(j);
                }
            }
        }

        return ans;
    }
};