leetcode刷题之滑动窗口

滑动窗口

参考:

1. LeetCode 滑动窗口（Sliding Window）类问题总结
2. 滑动窗口算法框架

//滑动窗口基本框架
//不要记框架，重点是理解滑动窗口的思想
int slidingWindowTemplate(String a, ...) {
    // 输入参数有效性判断
    if (...) {
        ...
    }

    // 申请一个散列，用于记录窗口中具体元素的个数情况
    unordered_map<...,...> hash;

    // 预处理(可省), 一般情况是改变 hash
    ...

    // left 表示左指针
    int left=0;
    // result用来存储结果
    typename result;

    // right 表示右指针
    // 移动右指针
    for (int right = 0; right < A.length; ++right) {
        //根据条件更新hash
        if(满足一定条件){
            更新hash
        }
        //这里通常是关键点和难点
        //满足一定条件或不满足一定条件更新左指针
        while (条件不满足 or 条件满足) {
            // 可能会更新结果(可选)
            // result=...
            ...
            //移动左指针,更新hash
            hash[A[l]]++;
            l++;
        }
        // 可能会更新结果(可选)
        // results = ...
    }
    return results;
}

Leetcode题目

• 76.最小覆盖子串
• 567.字符串的排列
• 438.找到字符串中所有字母异位词
• 3.无重复字符的最长子串
• 239.滑动窗口最大值
• 424.替换后的最长重复字符
• 632.最小区间
• 1423.可获得的最大点数

其中424.替换后的最长重复字符,632.最小区间,1423.可获得的最大点数都具有一定的技巧性，难度较大

76.最小覆盖子串

参考代码

class Solution {
public:
    string minWindow(string s, string t) {
        //定义hash,用于记录当前窗口中包含t中各字符的情况
        unordered_map<char,int> hash;
        //初始化hash,记录t中各字符的数量
        for(auto ch:t)
            ++hash[ch];
        //left为左指针
        int left=0;
        //result用来存储结果
        string result="";
        //移动右指针
        for(int right=0;right<s.size();++right){
            char rch=s[right];
            //若rch是t中的字符则更新hash
            if(hash.count(rch)){
                hash[rch]--;
            }
            //找到一个子串
            while(check(hash)){
                //取最小的字符串
                string window=s.substr(left,right-left+1);
                result=(result.empty()||window.size()<result.size()?window:result);
                //移动左指针
                char lch=s[left];
                if(hash.count(lch)){
                    hash[lch]++;
                }
                left++;
            }
        }
        return result;
    }
    bool check(const unordered_map<char,int> &hash){
        for(auto p:hash){
            //题目要求找涵盖t的子串，所以这里小于0的子串也是符合条件的
            //这里是小于等于0的都满足条件,注意!!!
            if(p.second>0) return false;
        }
        return true;
    }
};

567.字符串的排列

参考代码

和上一题类似，只是改变滑动窗口的条件不同.

class Solution {
public:
    bool checkInclusion(string s1, string s2) {
        //定义hash记录s1中各字符的数量
        unordered_map<char,int> hash;
        for(auto ch:s1)
            ++hash[ch];
        int left=0;
        for(int right=0;right<s2.size();++right){
            char rchar=s2[right];
            if(hash.count(rchar)){
                --hash[rchar];
            }
            //长度等于s1的长度，此时需要移动左指针
            if(right-left+1>=s1.size()){
                //判断当前窗口中的子串是否是s1的排列
                if(check(hash)) return true;
                //移动左指针
                char lchar=s2[left];
                if(hash.count(lchar)){
                    ++hash[lchar];
                }
                ++left;
            }
        }
        return false;
    }
    bool check(const unordered_map<char,int> &hash){
        for(auto p:hash){
            //这题是找排列，所以要全等于0才是满足条件的
            if(p.second!=0) return false;
        }
        return true;
    }
};

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

参考代码

和上一题一样，没有什么特色。

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        unordered_map<char,int> hash;
        for(auto ch:p)
            ++hash[ch];
        int left=0;
        vector<int> result;
        for(int right=0;right<s.size();++right){
            char rchar=s[right];
            if(hash.count(rchar)){
                --hash[rchar];
            }
            if(right-left+1>=p.size()){
                if(check(hash)) result.push_back(left);
                char lchar=s[left];
                if(hash.count(lchar)){
                    ++hash[lchar];
                }
                ++left;
            }
        }
        return result;
    }
    bool check(const unordered_map<char,int> &hash){
        for(auto p:hash){
            if(p.second!=0) return false;
        }
        return true;
    }
};

3.无重复字符的最长子串

参考代码

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if(s.empty()) return 0;
        unordered_map<char,int> hash;
        int left=0;
        int result=0;
        for(int right=0;right<s.size();++right){
            char rchar=s[right];
            ++hash[rchar];
            //这里保证滑动窗口中一定是不含有重复字符
            //若条件不满足，则移动左指针，直到条件满足
            while(!check(hash)){
                char lchar=s[left];
                --hash[lchar];
                ++left;
            }
            //更新结果
            result=max(result,(right-left+1));
        }
        return result;
    }
    bool check(const unordered_map<char,int> &hash){
        for(auto p:hash){
            if(p.second>1) return false;
        }
        return true;
    }
};

239.滑动窗口最大值

参考代码

这题的关键是想到用单调非递减的deque来保存最大值，次大值…
本质上是类单调栈与滑动窗口的结合.

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        //这里借助一个非递增的deque来保存窗口中的最大值，次大值...
        deque<int> intDeque;
        int left=0,maxValue=INT_MIN;
        vector<int> res;
        for(int right=0;right<nums.size();++right){
            //更新deque,保证dque的非递增性
            while((!intDeque.empty())&&(nums[intDeque.back()]<nums[right])){
                intDeque.pop_back();
            }
            intDeque.push_back(right);
            //移动左指针
            if(right-left+1>=k){
                int temp=intDeque.front();
                res.push_back(nums[temp]);
                //更新deque
                if(left==temp){
                    intDeque.pop_front();
                }
                left++;
            }
        }
        return res;
    }
};

424.替换后的最长重复字符(这题比较难理解…)

参考代码

class Solution {
public:
    int characterReplacement(string s, int k) {
        //用来记录滑动窗口中字符的情况
        vector<int> hash(26,0);
        //left表示左指针
        int left=0;
        //result记录结果
        int result=0;
        //maxCount并不是当前窗口内出现次数最多字母的次数，而是历史窗口中出现次数最多字母的次数
        //这道题的关键!!!
        int maxCnt=0;
        for(int right=0;right<s.size();++right){
            char rch=s[right];
            ++hash[rch-'A'];
            maxCnt=max(maxCnt,hash[rch-'A']);
            //始终保证滑动窗口中的子串是满足条件的
            //right-left+1-maxCnt即其余需要被替换的字符的数量
            //这里很巧妙，非常具有技巧性
            if(right-left+1-maxCnt>k){
                char lch=s[left];
                //这里有个问题需要思考，若maxCnt是left所指的字符，那么这里要不要更新maxCnt的值呢?
                //Answer:因为滑动窗口在这里只会扩大或者不变(++left,++right相互抵消)
                //       所以即使maxCnt是left所指的字符,maxCnt的值不正确了，依旧不会影响最终的结果
                --hash[lch-'A'];
                ++left;
            }
            //更新结果
            result=max(result,right-left+1);
        }
        return result;
    }
};

632.最小区间

参考代码

本题也极具技巧性…

class Solution {
public:
    vector<int> smallestRange(vector<vector<int>>& nums) {
        /*
        首先将 kk 组数据升序合并成一组，并记录每个数字所属的组，例如：

        [[4,10,15,24,26], [0,9,12,20], [5,18,22,30]][[4,10,15,24,26],[0,9,12,20],[5,18,22,30]]

        合并升序后得到：
        [(0, 1), (4, 0), (5, 2), (9, 1), (10, 0), (12, 1), (15, 0), (18, 2), (20, 1), (22, 2), (24, 0), (26, 0), (30, 2)][(0,1),(4,0),(5,2),(9,1),(10,0),(12,1),(15,0),(18,2),(20,1),(22,2),(24,0),(26,0),(30,2)]

        然后只看所属组的话，那么
        [1, 0, 2, 1, 0, 1, 0, 2, 1, 2, 0, 0, 2]

        只有当滑动窗口中包含所有区间时，才考虑滑动窗口的缩小
        [1 0 2] 2 1 0 1 0 2 1 2 0 0 2    [0, 5]
        1 [0 2 1] 1 0 1 0 2 1 2 0 0 2    [0, 5]
        1 0 [2 1 0] 0 1 0 2 1 2 0 0 2    [0, 5]
        1 0 [2 1 0 1] 1 0 2 1 2 0 0 2    [0, 5]
        1 0 [2 1 0 1 0] 0 2 1 2 0 0 2    [0, 5]
        1 0 2 1 0 [1 0 2] 2 1 2 0 0 2    [0, 5]
        1 0 2 1 0 1 [0 2 1] 1 2 0 0 2    [0, 5]
        1 0 2 1 0 1 [0 2 1 2] 2 0 0 2    [0, 5]
        1 0 2 1 0 1 0 2 [1 2 0] 0 0 2    [20, 24]
        1 0 2 1 0 1 0 2 [1 2 0 0] 0 2    [20, 24]
        1 0 2 1 0 1 0 2 [1 2 0 0 2] 2    [20, 24]

        */

        //初始化
        vector<vector<int>> ordered;
        for(int i=0;i<nums.size();++i){
            for(auto num:nums[i]) ordered.push_back({num,i});
        }
        sort(ordered.begin(),ordered.end());
        //定义hash，记录滑动窗口每一个组中所含的数字个数
        unordered_map<int,int> hash;
        //res存储最小区间
        vector<int> res;
        //left表示左指针,k表示区间数量
        int left=0,k=0;
        for(int right=0;right<ordered.size();++right){
            int rid=ordered[right][1];
            //判断滑动窗口是否第一次包含该区间
            if(hash[rid]==0) ++k;
            ++hash[rid];
            //滑动窗口中包含所有区间后才开始考虑缩小滑动窗口
            if(k==nums.size()){
                //滑动窗口中包含多个左指针所指的区间中的数
                //此时缩小滑动窗口
                while(hash[ordered[left][1]]>1){
                    --hash[ordered[left][1]];
                    ++left;
                }
                //更新结果
                if(res.empty()||ordered[right][0]-ordered[left][0]<res[1]-res[0]){
                    res=vector({ordered[left][0],ordered[right][0]});
                }
            }
        }
        return res;
    }
};

1423.可获得的最大点数

参考代码

class Solution {
public:
    int maxScore(vector<int>& cardPoints, int k) {
        //关键所在:要从两边取到最大值，相当于要找到一个长度为n-k的最小和中间数组

        //total_sum记录总的和,cur_sum记录当前滑动窗口中的和
        int total_sum=0,cur_sum=0;
        for(auto point:cardPoints) total_sum+=point;
        //滑动窗口的大小至少为1，否则直接返回总和
        if(k==cardPoints.size()) return total_sum;
        //滑动窗口的最大大小
        int left=0,sz=cardPoints.size()-k;
        //result记录可以获得的最大点数,result=toatl_sum-cur_sum
        int result=0;
        for(int right=0;right<cardPoints.size();++right){
            cur_sum+=cardPoints[right];
            //保持滑动窗口的大小
            if(right-left+1>=sz){
                //更新结果
                result=max(result,total_sum-cur_sum);
                //移动左指针
                cur_sum-=cardPoints[left];
                ++left;
            }
        }
        return result;
    }
};