滑动窗口法

 209.长度最小的子数组

 76.最小覆盖子串

209.最小的子数组 

        给定一个含有 n 个正整数的数组和一个正整数 target ，找出该数组中满足其和 ≥ target  的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

输入：s = 7, nums = [2,3,1,2,4,3]

输出：2

解释：子数组 [4,3] 是该条件下的长度最小的子数组。

#暴力解法（双指针滑动）

接下来就开始介绍数组操作中另一个重要的方法：滑动窗口。

所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。

在本题中实现滑动窗口，主要确定如下三点：

• 窗口内是什么？
• 如何移动窗口的起始位置？
• 如何移动窗口的结束位置？

窗口就是 满足其和 ≥ targer 的长度最小的 连续 子数组。

窗口的起始位置如何移动：如果当前窗口的值大于target了，窗口就要向前移动了（也就是该缩小了）。

窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，也就是for循环里的索引。

在暴力解法中，是一个for循环i滑动窗口的起始位置，一个for循环j为滑动窗口的终止位置，用两个for循环完成了一个不断搜索区间的过程。

那么问题来了， 滑动窗口的起始位置如何移动呢？这里还是以题目中的示例来举例，

target = 7， 数组是 [ 2，3，1，2，4，3 ] 来看一下查找的过程：

最后找到 4，3 是最短距离。

其实从动画中可以发现滑动窗口也可以理解为双指针法的一种！只不过这种解法更像是一个窗口的移动，所以叫做滑动窗口更适合一些。

// 暴力解法
// 时间复杂度O(n^2)
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int Sum = 0, Length = 0; 
        // 初始值要赋整数最大，如果赋0，在第13行，Result会一直为0
        int Result = INT32_MAX;        
        // 存在最后一个元素恰好≥target的情况，所以i一直取到最后        
        for (int i = 0; i < nums.size(); ++i){     
            Sum = 0;                               // break跳出后，sum一定要置零 
            for (int j = i; j < nums.size(); ++j){ // 要求连续，从i的位置开始向后累加
                Sum += nums[j];
                if (Sum >= target){
                    Length = j - i + 1;  // 累加的起始下标是i，终止下标是j，所以跨度为 j-i+1
                    Result = Length < Result ? Length : Result;
                   
                    /*已经找到以当前i为起始节点累加后≥target的情况，再往后加只会让最终长度更大，
                    所以直接跳出j这个for循环,让i++，从下一个元素开始继续往后寻找累加 */
                    break;   
                }
            }
        }
        // 如果result没有被赋值的话，说明没找到相加满足条件的长度，就返回0
        return Result == INT32_MAX ? 0 : Result;  
    }
};

这种方法在力扣上，有些示例会超时。下面来看看优化后滑动窗口的方法

#滑动窗口

那么滑动窗口如何用一个for循环来完成这个操作呢。首先要思考如果用一个for循环，那么应该表示滑动窗口的起始位置，还是终止位置。如果只用一个for循环来表示滑动窗口的起始位置，那么如何遍历剩下的终止位置？

此时难免再次陷入暴力解法的怪圈。

所以只用一个for循环，那么这个循环的索引 j，一定是表示滑动窗口的终止位置。

 sum - nums[i] 后就只剩下原滑动窗口除去起始位置的其他元素之和了，再 i++ 将窗口的起始位置后移

// 改进的滑动窗口，j仍然指向终止，i指向起始但不在用for
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int Sum = 0;                            // 滑动窗口数值之和
        int Length = 0;                         // 滑动窗口的长度
        int i = 0;                              // 滑动窗口起始位置
        int Result = INT32_MAX;                 // 最短子序列
 
        for (int j = i; j < nums.size(); ++j){ // 从i的位置开始向后累加
            Sum += nums[j];

            while(Sum >= target){
                Length = j - i + 1;            
                Result = Length < Result ? Length : Result;
                 
                // 将原窗口起始节点移出，让i的下标后移指向下一个新起始 
                Sum -= nums[i++];            
            }
        }
        // 如果result没有被赋值的话，说明没找到相加满足条件的长度，就返回0
        return Result == INT32_MAX ? 0 : Result;  
    }
};

可以发现滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)暴力解法降为O(n)。

76. 最小覆盖子串

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

注意：

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

示例 1：

输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"

示例 2：

输入：s = "a", t = "a"
输出："a"

示例 3:

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

1、思路
(滑动窗口) O(n)O(n)

这道题要求我们返回字符串 s中包含字符串 t 的全部字符的最小窗口，我们利用滑动窗口的思想解决这个问题。因此我们需要两个哈希表，hs哈希表维护的是s字符串中滑动窗口中各个字符出现多少次，ht哈希表维护的是t字符串各个字符出现多少次。如果hs哈希表中包含ht哈希表中的所有字符，并且对应的个数都不小于ht哈希表中各个字符的个数，那么说明当前的窗口是可行的，可行中的长度最短的滑动窗口就是答案。

过程如下：

1、遍历 t 字符串，用 ht 哈希表记录 t 字符串各个字符出现的次数。

2、定义两个指针 j 和 i，j 指针用于收缩窗口，i 指针用于延伸窗口，则区间[ j ,i ]表示当前滑动窗口。首先让 i 和 j 指针都指向字符串 s 开头，然后枚举整个字符串s ，枚举过程中，不断增加i使滑动窗口增大，相当于向右扩展滑动窗口。

3、每次向右扩展滑动窗口一步，将 s [ i ] 加入滑动窗口中，而新加入了s [ i ]，相当于滑动窗口维护的字符数加一，即hs [ s[ i ] ]++。

4、对于新加入的字符s [ i ] ,如果hs[ s[ i ] ] <= ht[ s[ i ] ]，说明当前新加入的字符 s [ i ]是必需的，且还未到达字符串t所要求的数量。我们还需要事先定义一个 cnt 变量， cnt 维护的是 s 字符串[ j , i ] 区间中满足 t 字符串的元素的个数，记录相对应字符的总数。新加入的字符 s[ i ] 必需，则 cnt ++。

5、我们向右扩展滑动窗口的同时也不能忘记收缩滑动窗口。因此当hs[ s[ j ] ] > ht[ s[ j ] ]时，说明hs 哈希表中 s[ j ] 的数量多于 ht 哈希表中 s[ j ] 的数量，此时我们就需要向右收缩滑动窗口，j++并使hs[ s[ j ] ]--，即hs[s[j ++ ] ] --

6、当 cnt == t.size 时，说明此时滑动窗口包含符串 t 的全部字符。我们重复上述过程找到最小窗口即为答案。

时间复杂度分析： 两个指针都严格递增，最多移动 n 次，所以总时间复杂度是 O(n)。

class Solution {
public:
    string minWindow(string s, string t) {
        unordered_map<char, int> hs, ht;
        for (auto c: t) ht[c] ++ ;
        string res;
        int cnt = 0;
        for (int i = 0, j = 0; i < s.size(); i ++ ) {
            hs[s[i]] ++ ;
            if (hs[s[i]] <= ht[s[i]]) cnt ++ ;

            while (hs[s[j]] > ht[s[j]]) hs[s[j ++ ]] -- ;
            if (cnt == t.size()) {
                if (res.empty() || i - j + 1 < res.size())
                    res = s.substr(j, i - j + 1);
            }
        }
        return res;
    }
};

PS:

unordered_map是一个将key和value关联起来的容器，它可以高效的根据单个key值查找对应的value。

unordered_map存储元素时是没有顺序的，只是根据key的哈希值，将元素存在指定位置，所以根据key查找单个value时非常高效，平均可以在常数时间内完成。

unordered_map查询单个key的时候效率比map高，但是要查询某一范围内的key值时比map效率低。

头文件：#include<unordered_map>