LeetCode滑动窗口

之前刷了不少和滑动窗口相关的题目，但是一直没有好好地去总结，最近刚好看到LeetCode上一位大佬labuladong写的一篇滑动窗口的模板，觉得很有意义。下面结合我自己的理解重新的总结和归纳一下，部分内容参考labuladong的文章。

首先应该明白 滑动窗口一般是用来解决这样一类问题:
给定一个字符串或者数字序列，找到这个序列中符合特定要求的子序列，比如LeetCode3 （无重复字符的最长子串），LeetCode438 （找到字符串中所有字母异位词）等等。我们一般用一个哈希表或者数组来充当这样一个窗口，通过不断的移动窗口最后找到一个符合要求的全局最优解。

首先我们直接给出模板如下

给定一个序列s,初始化窗口为0
left=0，right=0;
while(right<s.size())
{
   window.add(s[right]) //s[right]满足题目要求，将其加入窗口
   ++right;
   
  // valid具体如何转化成代码需要根据题目要求
  while(valid) //当前窗口内存在一个我们需要的解，并且一定包括right边界，所以接下来就需要处理left
  {
    window.remove(s[left]);
    ++left;
  }
}

具体实例
LeetCode3 无重复字符的最长子串

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
    int left = 0, right = 0;
    unordered_map<char, int> window;
    int res = 0; 

    while (right < s.size()) {
        char c1 = s[right];
        window[c1]++;
        right++;
        
        while (window[c1] > 1) {
            char c2 = s[left];
            window[c2]--;
            left++;
        }
        res = max(res, right - left);
    }
    return res;
}
};

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

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        unordered_map<char,int>need;
        unordered_map<char,int>window;
        vector<int>res;
        for(auto c:p)
           ++need[c];
        int cnt=0,l=0,r=0;
        while(r<s.size())
        {
            char c1=s[r];
            if(need.count(c1))
            {
                ++window[c1];
                if(window[c1]==need[c1])
                    ++cnt;    
            }
            ++r;
            while(cnt==need.size())
            {
                if(r-l==p.size())
                {
                    res.push_back(l);
                }
                char c2=s[l];
                if(need.count(c2))
                {
                  --window[c2];
                  if(window[c2]<need[c2])
                    --cnt;
                }
                ++l;
                
            }
            
        }
        return res;
    }
};

LeetCode76
最小覆盖子串

class Solution {
public:
    string minWindow(string s, string t) {
     
        unordered_map<char,int>window;
        unordered_map<char,int>needs;
        for(auto c:t)
            ++needs[c]; 
        int l=0,r=0,cnt=0,min=INT_MAX;
        vector<int>res(2,-1);
        while(r<s.size())
        {
            auto c1=s[r];
            if(needs.count(c1))
            {
                ++window[c1];
                if(window[c1]==needs[c1])
                    ++cnt;
               
            }
            ++r;
            
            while(cnt==needs.size())
            {
                 if(min>r-l)
                 {
                    res[0]=l;res[1]=r-1; 
                    min=r-l;
                 }
                  auto c2=s[l];
                  if(needs.count(c2))
                  {
                      --window[c2];
                      if(window[c2]<needs[c2])
                          --cnt;
                  }
                 ++l;     
            }
    
        }
        if(res[0]==-1)return "";
        return s.substr(res[0],res[1]-res[0]+1);
    }
};