算法随手记-滑动窗口Day10

1.串联所有单词的子串

给定一个字符串 s 和一个字符串数组 words。 words 中所有字符串 长度相同。

s 中的 串联子串 是指一个包含 words 中所有字符串以任意顺序排列连接起来的子串。

• 例如，如果 words = ["ab","cd","ef"]， 那么 "abcdef"， "abefcd"，"cdabef"， "cdefab"，"efabcd"， 和 "efcdab" 都是串联子串。 "acdbef" 不是串联子串，因为他不是任何 words 排列的连接。

返回所有串联子串在 s 中的开始索引。你可以以 任意顺序 返回答案。

示例

入：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"] 顺序排列的连接。

思路

暴力解法

• 首先判断长度，words 中所有字符串的长度为n，如果s的长度小于n*words.length那么直接返回空
• 先指定两个指针start，end；end每次移动n来获取子串，如果字串包含words其中的一个字符串，继续向后移动长度n，再判断是否还是拥有，如果不再拥有那继续遍历，并使用map的计数方式来判断子字符串是否重复

	public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> list = new ArrayList<>();
        Map<String, Integer> wordCount = new HashMap<>();
        
        // 统计words中每个单词的出现次数
        for (String word : words) {
            wordCount.put(word, wordCount.getOrDefault(word, 0) + 1);
        }
        
        int n = words[0].length();
        int totalLength = words.length * n;
        
        // 如果字符串长度小于总长度，直接返回空列表
        if (s.length() < totalLength) {
            return list;
        }
        
        // 遍历所有可能的起始位置
        for (int i = 0; i <= s.length() - totalLength; i++) {
            Map<String, Integer> tempMap = new HashMap<>(wordCount);
            boolean isValid = true;
            
            // 检查从位置i开始的totalLength个字符
            for (int j = 0; j < words.length; j++) {
                int start = i + j * n;
                int end = start + n;
                String currentWord = s.substring(start, end);
                
                // 如果当前单词不在map中或者已经用完，则无效
                if (!tempMap.containsKey(currentWord) || tempMap.get(currentWord) <= 0) {
                    isValid = false;
                    break;
                }
                
                // 减少当前单词的计数
                tempMap.put(currentWord, tempMap.get(currentWord) - 1);
            }
            
            // 如果所有单词都匹配，添加起始位置
            if (isValid) {
                list.add(i);
            }
        }
        
        return list;
    }

问题

复杂度过高

滑动窗口

        int wordLen = words[0].length(); // 一个单词的长度
        int windowLen = wordLen * words.length; // 所有单词的总长度，即窗口大小
        Map<String, Integer> targetCnt = new HashMap<>(); //将words中的所有字符串都存入这里并计数
		Map<String, Integer> cnt = new HashMap<>(); //将需要判断的子字符串存入其中，并计数
		int overload = 0;//用来判断Cnt中子字符串的数量是否超过targetCnt的数量，如果超过了就+1

1.首先我们要把words中的字符串保存到一个HashMap中，并计数wordsCnt（其实这里可以把所有wordsCnt都看作1，但是因为words中的字符串可能会出现重复的情况，所以还是应该老实的+1）

        Map<String, Integer> targetCnt = new HashMap<>();
        for (String w : words) {
            targetCnt.merge(w, 1, Integer::sum); // targetCnt[w]++
        }

2.把s中words[0].length()长度的字符看作一个整体newString，遍历判断他们中是否存在连续三个拥有words中的所有字符串，判断的话使用滑动窗口的思想

• 滑动窗口存入一个newString：将字符串存入HashMap中，并将计数器StringCnt+1
• 判断：两个HashMap都取出newString，StringCnt和wordsCnt对比，如果满足条件，那么应该StringCnt == wordsCnt，如果Cnt中子字符串的数量是否超过targetCnt的数量，如果超过了就+1。而且光满足计数值相同还不行，我们还得保证map中存放了三个newString，即窗口的右端点 > totalLength，这样才能够保证获得的结果是正确的

                if (cnt.getOrDefault(inWord, 0).equals(targetCnt.getOrDefault(inWord, 0))) {
                    overload++;//判断Cnt中子字符串的数量是否超过targetCnt的数量，如果超过了就+1
                }

				int left = right - windowLen; // 窗口第一个单词的左端点
                if (right < windowLen) { // 窗口大小不足 windowLen
                    continue;
                }

• 滑动窗口移除第一个newString，并将计数器StringCnt-1

3.这样只需要遍历words[0].length()即可，因为后面的字符都已经使用滑动窗口遍历判断过了

    public List<Integer> findSubstring(String s, String[] words) {
        int wordLen = words[0].length(); // 一个单词的长度
        int windowLen = wordLen * words.length; // 所有单词的总长度，即窗口大小

        // 目标：窗口中的单词出现次数必须与 targetCnt 完全一致
        Map<String, Integer> targetCnt = new HashMap<>();
        for (String w : words) {
            targetCnt.merge(w, 1, Integer::sum); // targetCnt[w]++
        }

        List<Integer> ans = new ArrayList<>();
        // 枚举窗口起点，做 wordLen 次滑动窗口
        for (int start = 0; start < wordLen; start++) {
            Map<String, Integer> cnt = new HashMap<>();
            int overload = 0;
            // 枚举窗口最后一个单词的右端点+1
            for (int right = start + wordLen; right <= s.length(); right += wordLen) {
                // 1. inWord 进入窗口
                String inWord = s.substring(right - wordLen, right);
                // 下面 cnt[inWord]++ 后，inWord 的出现次数过多
                if (cnt.getOrDefault(inWord, 0).equals(targetCnt.getOrDefault(inWord, 0))) {
                    overload++;
                }
                cnt.merge(inWord, 1, Integer::sum); // cnt[inWord]++

                int left = right - windowLen; // 窗口第一个单词的左端点
                if (right < windowLen) { // 窗口大小不足 windowLen
                    continue;
                }

                // 2. 更新答案
                // 如果没有超出 targetCnt 的单词，那么也不会有少于 targetCnt 的单词
                if (overload == 0) {
                    ans.add(left);
                }

                // 3. 窗口最左边的单词 outWord 离开窗口，为下一轮循环做准备
                String outWord = s.substring(left, left + wordLen);
                cnt.merge(outWord, -1, Integer::sum); // cnt[outWord]--
                if (cnt.get(outWord).equals(targetCnt.getOrDefault(outWord, 0))) {
                    overload--;
                }
            }
        }

        return ans;
    }

后续还要去继续练习1456：定长子串中元音的最大数目