LeetCode（32）串联所有单词的子串【滑动窗口】【困难】（含图解）

链接： 串联所有单词的子串

1.题目

给定一个字符串 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] 也是可以的。
1
2
3
4
5
6

示例 2：

输入：s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
输出：[]
解释：因为 words.length == 4 并且 words[i].length == 4，所以串联子串的长度必须为 16。
s 中没有子串长度为 16 并且等于 words 的任何顺序排列的连接。
所以我们返回一个空数组。
1
2
3
4
5

示例 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
2
3
4
5
6

提示：

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

---

2.答案

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> result = new ArrayList<>();
        int wordLength = words[0].length();
        int wordCount = words.length;
        for (int i = 0; i < wordLength; i++) {
            // 超出长度
            if (i + wordCount * wordLength > s.length()) {
                break;
            }
            // 初始化窗口
            Map<String, Integer> map = new HashMap<>();
            for (int j = 0; j < wordCount; j++) {
                String word = s.substring(i + j * wordLength, i + (j + 1) * wordLength);
                map.put(word, map.getOrDefault(word, 0) + 1);
            }
            // 筛掉原单词数组
            for (String word : words) {
                map.put(word, map.getOrDefault(word, 0) - 1);
                if (map.get(word) == 0) {
                    map.remove(word);
                }
            }
            // 滑动窗口
            for (int j = 0; i + j + wordCount * wordLength <= s.length(); j+=wordLength) {
                if (j != 0) {
                    String addWord = s.substring(i + j + wordLength * (wordCount - 1), i + j + wordLength * wordCount);
                    map.put(addWord, map.getOrDefault(addWord, 0) + 1);
                    if (map.get(addWord) == 0) {
                        map.remove(addWord);
                    }
                    String delWord = s.substring(i + j - wordLength, i + j);
                    map.put(delWord, map.getOrDefault(delWord, 0) - 1);
                    if (map.get(delWord) == 0) {
                        map.remove(delWord);
                    }
                }
                if (map.size() == 0) {
                    result.add(i + j);
                }
            }
        }
        return result;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

---

3.提交结果截图

4.图解

以如下测试用例举例说明：

输入：s = "barfoothefoobarman", words = ["foo","bar"]
输出：[0,9]
1
2

首先，可以将字符串 s 按照单词长度进行划分，通过开头跳过字符长度的方式，可以分为以下三种划分方式。

以划分方式1举例，可以将所有单词总长度（单词数 * 单词长度）来作为一个窗口，从左往右滑动。

最终得到的 index=0 和 index=9 就是我们的结果了。

整理完毕，完结撒花~ 🌻