hot100 子串 - 技术栈

和为k的子数组

560. 和为 K 的子数组 - 力扣（LeetCode）

解题思路：

本题思路在于如何才能统计到连续的子数组并且保证能够不漏下结果

这里就需要用到前缀和和哈希表，通过哈希表来统计每个前缀和也可以理解为每个连续的子数组的值出现的次数。

前缀和用来保证连续，哈希表来保证不会漏下结果

首先需要对哈希表0的key进行初始化为1，因为可能会遇到nums中只有一个值，并且这个值也等于k，此时计算前缀和后减去k，如果在前面没有对0的位置进行初始化，此时就无法收集到这个结果，返回的就是0，但我们应该返回1。

本题的主要判断条件和两数之和非常相像，不同就在于本题需要统计所有可能出现的结果。

详细代码如下：

cpp 复制代码

   int subarraySum(vector<int>& nums, int k){
        unordered_map<int, int> ma;//key为出现过的数值，value为该数值出现过的次数
        ma[0] = 1;
        int res = 0, pre = 0;
        for(int n : nums){
            pre+=n;
            if(ma.find(pre-k)!=ma.end()){
                res += ma[pre-k];
            }
            ma[pre]++;
        }
        return res;
    }

滑动窗口最大值

239. 滑动窗口最大值 - 力扣（LeetCode）

解题思路：

自定义队列，将每个区间的最大值都维护在对头的位置

以上面的示例举例：

初始状态1、3、-1、-3、5、3、6、7 k = 3

1、前k个元素进行push，当前窗口状态：-1 3，1被后面进来的3pop掉了 max = 3

2、i = 3，pop（1）因为被pop掉了并且不等于front，所以忽略，push（-3）当前窗口：-3 -1 3

max = 3

3、i = 4，pop（3）因为等于对头的最大的元素，进行pop， push（5）当前窗口：5

max = 5 因为push5导致队列中小于5的全部pop出去，当前只剩5

4、i = 5，pop（-1）因为不等于当前对头元素，因此忽略，push（3）当前窗口：3 5

max = 5 因为push的3小于对头的最大的5，因此不用pop直接push进去

5、i = 6，pop（-3）因为不等于当前对头元素，因此忽略，push（6）当前窗口：6

max = 6 ，因为push的6是最大的，队列中的元素会全被pop出去

6、i = 7，pop（5）因为不等于当前对头的元素，因此忽略，push（7）当前窗口：7

max = 7 因为push的7是最大的，会将队列中的元素全部pop出去

最后的序列为：3 3 5 5 6 7

下面为具体代码：

cpp 复制代码

class MyQueue{
private:
    deque<int> que;
public:
//如果队列不为空并且当前元素，与队列的头元素相同，说明要出队列
        //当前队头元素不属于接下来的窗口中的数了
        void pop(int value) {//只有当当前元素和对头元素也就是最大的元素相同时才会出队
                    //也就是走到前一个窗口中最大值的位置把这个pop出去
            if (!que.empty() && value == que.front()) {
                que.pop_front();
            }
        }
        //当前的元素和队列中前面的元素进行比较，如果前面的元素大小没有
        //当前元素大，那么就出栈，不需要进行维护，只需要对可能是最大的
        //那个元素进行维护。
        void push(int value) {
            while (!que.empty() && value > que.back()) {
                que.pop_back();
            }
            que.push_back(value);
        }
        //查找当前队列中的最大值
        int front() {
            return que.front();
        }
};

cpp 复制代码

vector<int> maxSlidingWindow(vector<int>& nums, int k){
        MyQueue que;
        vector<int> res;
        for(int i = 0;i<k;i++){
            que.push(nums[i]);
        }
        res.push_back(que.getMax());//记录当前窗口最大值
        for(int i = k;i<nums.size();i++){
            que.pop(nums[i-k]);//收缩左边界
            que.push(nums[i]);//扩展右边界
            res.push_back(que.getMax());
        }
        return res;
    }

最小覆盖字串

76. 最小覆盖子串 - 力扣（LeetCode）

解题思路：

本题思路其实和第一题差不多，只不过这个结果只需要输出最小的哪个覆盖子串。因此这里只需要数组进行统计即可，不需要哈希表去记录下标或出现次数。

我们需要自己去判断是否当前区间中的子串是否覆盖了匹配串。如果覆盖并更新最小的长度然后收缩左边界，直到不覆盖了退出扩展右边界

cpp 复制代码

    //判断是否覆盖
    bool iscover(int ss[], int tt[]){
        for(int i = 'A';i<='Z';i++){
            if(ss[i]<tt[i]){
                return false;
            }
        }
        for(int i = 'a';i<='z';i++){
            if(ss[i]<tt[i]){
                return false;
            }
        }

        return true;
    }
    string minWindow(string s, string t){
        int ss[128]{};
        int tt[128]{};
        for(int i = 0;i<t.size();i++){//根据ASCII码作为标识记录
            tt[t[i]]++;
        }
        int m = s.size();
        int res_left = -1, res_right = m;
        int left = 0;
        for(int right = 0;right<m;right++){
            ss[s[right]]++;//扩展右边界
            while(iscover(ss, tt)){
                //如果有更小的覆盖结果集，便更新
                if(right-left<res_right-res_left){
                    res_left = left;
                    res_right = right;
                }
                //收缩左区间
                ss[s[left]]--;
                left++;
            }
        }
        return res_left<0?"":s.substr(res_left, res_right-res_left+1);
    }