滑动窗口--（完结篇）

找到字符串中所有字母异位词

给定两个字符串 s 和 p，找到 s 中所有 p 的

异位词

的子串，返回这些子串的起始索引。不考虑答案输出的顺序。

示例 1:

输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。

示例 2:

输入: s = "abab", p = "ab"
输出: [0,1,2]
解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。

提示:

• 1 <= s.length, p.length <= 3 * 104
• s 和 p 仅包含小写字母

解法（滑动窗⼝ + 哈希表）：

算法思路：

◦ 因为字符串 p 的异位词的⻓度⼀定与字符串 p 的⻓度相同，所以我们可以在字符串 s 中构 造⼀个⻓度为与字符串 p 的⻓度相同的滑动窗⼝，并在滑动中维护窗⼝中每种字⺟的数量；

◦ 当窗⼝中每种字⺟的数量与字符串 p 中每种字⺟的数量相同时，则说明当前窗⼝为字符串 p 的异位词；

◦ 因此可以⽤两个⼤⼩为 26 的数组来模拟哈希表，⼀个来保存 s 中的⼦串每个字符出现的个 数，另⼀个来保存 p 中每⼀个字符出现的个数。这样就能判断两个串是否是异位词。

class Solution
{
public:
 vector<int> findAnagrams(string s, string p) 
 {
 vector<int> ret;
 int hash1[26] = { 0 }; // 统计字符串 p 中每个字符出现的个数
 for(auto ch : p) hash1[ch - 'a']++;
 int hash2[26] = { 0 }; // 统计窗⼝⾥⾯的每⼀个字符出现的个数
 int m = p.size();
 for(int left = 0, right = 0, count = 0; right < s.size(); right++)
 {
 char in = s[right];
 // 进窗⼝ + 维护 count
 if(++hash2[in - 'a'] <= hash1[in - 'a']) count++; 
 if(right - left + 1 > m) // 判断
 {
 char out = s[left++];
 // 出窗⼝ + 维护 count
 if(hash2[out - 'a']-- <= hash1[out - 'a']) count--; 
 }
 // 更新结果
 if(count == m) ret.push_back(left);
 }
 return ret;
 }
};

串联所有单词的子串

给定一个字符串 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 由小写英文字母组成

解法⼀（暴⼒解法）：

算法思路：

如果我们把每⼀个单词看成⼀个⼀个字⺟，问题就变成了找到「字符串中所有的字⺟异位词」。⽆ ⾮就是之前处理的对象是⼀个⼀个的字符，我们这⾥处理的对象是⼀个⼀个的单词。


代码如下：

class Solution 
{
public:
    vector<int> findSubstring(string s, vector<string>& words) 
    {
        vector <int> ret;
        unordered_map<string,int> hash1;//保存word里面所有单词的频次
        for(auto &s:words) hash1[s]++;
        int len=words[0].size(),m=words.size();//len表示单词数组中每一个单词的长度
        for(int i=0;i<len;i++)
        {
            unordered_map<string,int> hash2;//维护窗口内单词的频次
            for(int left=i,right=i,count=0;right+len<=s.size();right+=len)
            {
                //进窗口+维护count
                string in=s.substr(right,len);
                hash2[in]++;
                if(hash1.count(in)&&hash2[in]<=hash1[in]) count++;//这里先判断word单词频次，不用再二次创建，提高效率
                //判断
                if(right-left+1>m*len) 
                {
                    //出窗口+维护count
                    string out=s.substr(left,len);
                    if(hash1.count(out)&&hash2[out]<=hash1[out]) count--;
                    hash2[out]--;
                    left+=len;
                }
                if(count==m) ret.push_back(left);
            }

        }
        return ret;
    }
};

最小覆盖子串

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。

注意：

• 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
• 如果 s 中存在这样的子串，我们保证它是唯一的答案。

示例 1：

输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"
解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。

示例 2：

输入：s = "a", t = "a"
输出："a"
解释：整个字符串 s 是最小覆盖子串。

示例 3:

输入: s = "a", t = "aa"
输出: ""
解释: t 中两个字符 'a' 均应包含在 s 的子串中，
因此没有符合条件的子字符串，返回空字符串。

提示：

• m == s.length
• n == t.length
• 1 <= m, n <= 105
• s 和 t 由英文字母组成
  
  
  
  解法（滑动窗⼝ + 哈希表）：**

算法思路：

◦ 研究对象是连续的区间，因此可以尝试使⽤滑动窗⼝的思想来解决。

◦ 如何判断当前窗⼝内的所有字符是符合要求的呢？

我们可以使⽤两个哈希表，其中⼀个将⽬标串的信息统计起来，另⼀个哈希表动态的维护窗⼝ 内字符串的信息。

当动态哈希表中包含⽬标串中所有的字符，并且对应的个数都不⼩于⽬标串的哈希表中各个字 符的个数，那么当前的窗⼝就是⼀种可⾏的⽅案。

算法流程：

a. 定义两个全局的哈希表： 1 号哈希表 hash1 ⽤来记录⼦串的信息， 2 号哈希表 hash2 ⽤来记录⽬标串 t 的信息；

b. 实现⼀个接⼝函数，判断当前窗⼝是否满⾜要求：

i. 遍历两个哈希表中对应位置的元素：

• 如果 t 中某个字符的数量⼤于窗⼝中字符的数量，也就是 2 号哈希表某个位置⼤于 1 号哈希表。说明不匹配，返回 false ；

• 如果全都匹配，返回 true 。

主函数中：

a. 先将 t 的信息放⼊ 2 号哈希表中；

b. 初始化⼀些变量：左右指针： left = 0，right = 0 ；⽬标⼦串的⻓度： len = INT_MAX ；⽬标⼦串的起始位置： retleft ；（通过⽬标⼦串的起始位置和⻓度，我们就 能找到结果）

c. 当 right ⼩于字符串 s 的⻓度时，⼀直下列循环：

i. 将当前遍历到的元素扔进 1 号哈希表中；

ii. 检测当前窗⼝是否满⾜条件：

• 如果满⾜条件：

◦ 判断当前窗⼝是否变⼩。如果变⼩：更新⻓度 len ，以及字符串的起始位置 retleft ；

◦ 判断完毕后，将左侧元素滑出窗⼝，顺便更新 1 号哈希表；

d. 判断 len 的⻓度是否等于 INT_MAX ：

i. 如果相等，说明没有匹配，返回空串；

ii. 如果不想等，说明匹配，返回 s 中从 retleft 位置往后 len ⻓度的字符串。

代码如下：

class Solution 
{
public:
    string minWindow(string s, string t) 
    {
       int hash1[128]={0};// 统计字符串 t 中每⼀个字符的频次
       int kinds=0;// 统计有效字符有多少种
       for(auto ch:t)
       {
        if(hash1[ch]++==0) kinds++;// 统计窗⼝内每个字符的频次
       }
       int hash2[128]={0};
       int minlen=INT_MAX,begin=-1;
       for(int left=0,right=0,count=0;right<s.size();right++)
       {
            char in=s[right];
            if(++hash2[in]==hash1[in]) count++;// 进窗⼝ + 维护 count
            while(count==kinds)// 判断条件
            {
                if(right-left+1<minlen)// 更新结果
                {
                    minlen=right-left+1;
                    begin=left;
                }
                char out=s[left++];
                if(hash2[out]--==hash1[out]) count--;// 出窗⼝ + 维护 count
            }
       }
       if(begin==-1)
       {
        return "";
       }
       else return s.substr(begin,minlen);
    }
};