leetcode全部滑动窗口题目总结C++写法(完结)

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

A：

要找最长的无重复子串，所以用一个map保存出现过的字符，并且维持一个窗口，用le和ri指针标识。ri为当前要遍历的字符，如果ri字符在map中出现过，那么将le字符从map移除，le++。如果ri字符没出现过，那ri++，并更新最大无重复子串长度。全程利用map保持无重复的要求，每次循环要么le++，要么ri++。最差情况是n个一样的字符，那么ri++，le++，ri++，le++这样一直从0循环到n-1。时间复杂度和空间复杂度都是O(N)。

 class Solution {
 public:
     int lengthOfLongestSubstring(string s) {
         if(s.empty()){return ;}
         int le=,ri=;
         map<char,int> dic;
         dic[s[]]+=;
         int max_len=;
         while(ri<s.size()){
             if(dic[s[ri]]){
                 dic[s[le]]-=;
                 ++le;
             }
             else{
                 dic[s[ri]]+=;
                 ++ri;
                 max_len=max(max_len,ri-le);

             }
         }
         return max_len;
     }
 };

30. 串联所有单词的子串

A：

题目指定了所有单词是一样长度的，那么我们就可以按单词为单位进行查找。假如单词长度为3，那么从0、1、2分别按单词长度进行查找，一直查找到字符串结尾，就可以查找到所有满足条件的子串。

 class Solution {
 public:
     vector<int> findSubstring(string s, vector<string>& words) {
         if(s.empty() or words.empty()){
             return vector<int>();
         }
         int s_len=s.length(),one_word=words[].size(),all_word=words.size()*one_word,word_cnt=words.size();
         if(all_word>s_len){
             return vector<int>();
         }
         map<string,int> dic;
         for(const string& word:words){
             dic[word]+=;
         }
         vector<int> res;
         for(int i=;i<one_word;++i){
             int le=i,ri=i,cnt=;
             map<string,int> cur_dic;
             while(ri+one_word-<s_len){    //ri开头的单词结尾不能越界
                 string cur=s.substr(ri,one_word);    //当前单词
                 if(dic[cur]==){    //无匹配
                     ri+=one_word;
                     le=ri;
                     cnt=;
                     cur_dic.clear();
                 }
                 else{    //匹配
                     ri+=one_word;
                     cur_dic[cur]+=;
                     ++cnt;
                     while(dic[cur]<cur_dic[cur]){
                         string w=s.substr(le,one_word);
                         cur_dic[w]-=;
                         le+=one_word;
                         --cnt;
                     }
                     if(cnt==word_cnt){
                         res.push_back(le);
                     }
                 }
             }
         }
         return res;
     }
 };

但是稍微改动一下：

 class Solution {
 public:
     vector<int> findSubstring(string s, vector<string>& words) {
         if(s.empty() or words.empty()){
             return vector<int>();
         }
         int s_len=s.length(),one_word=words[].size(),all_word=words.size()*one_word,word_cnt=words.size();
         if(all_word>s_len){
             return vector<int>();
         }
         map<string,int> dic;
         for(const string& word:words){
             dic[word]+=;
         }
         vector<int> res;
         for(int i=;i<one_word;++i){
             int le=i,ri=i,cnt=;
             unordered_map<string,int> cur_dic;
             while(ri+one_word-<s_len){    //ri开头的单词结尾不能越界
                 string cur=s.substr(ri,one_word);    //当前单词
                 if(dic.count(cur) and cur_dic[cur]<dic[cur]){
                     ++cnt;
                     cur_dic[cur]+=;
                     ri+=one_word;
                 }
                 else{
                     if(dic.count(cur)==){    //ri开头的单词不在单词表里
                         ri+=one_word;    //ri后移一个单词长度
                         if(ri+one_word->=s_len){
                             break;
                         }
                         //因为之前ri开头的单词gg了，那么移动le到新的ri重新开始
                         le=ri;
                         cur_dic.clear();
                         cnt=;
                     }
                     else{    //cur_dic[cur]>=dic[cur]，le一直右移直到cur_dic[cur]<dic[cur]使得cur能插入
                         while(cur_dic[cur]>=dic[cur]){
                             cur_dic[s.substr(le,one_word)]-=;
                             le+=one_word;
                             --cnt;
                         }
                     }
                 }
                 if(cnt==word_cnt){
                     res.push_back(le);
                     cur_dic[s.substr(le,one_word)]-=;
                     le+=one_word;
                     --cnt;
                 }
             }
         }
         return res;
     }
 };

改动的地方只是把dic[cur]==0改成了dic.count(cur)==0。对于dic中不存在的cur，前者会自动假如加入 dic，默认值为0。所以内存用量一下从14M变成了26M，同时map的查询时间是log级别，所有的查map时间也会有相应增加，这一点一定要注意。

76. 最小覆盖子串

A:

写了两遍，代码基本的结构一致，唯一一点区别是第一种是先一直向右寻找直到找到覆盖t的子串，再尽量把左边界右移加入结果。
第二种是每次循环只向右跳一个字符，如果还没找到覆盖t的子串就记录并把左边界尽量右移，找到的话就加入结果。其实写到这我发现这俩解法没啥区别，就不说了吧。
另外看见题解里有一种解法是把s串中属于t串的字符挑出来记录成map，这样在遍历s寻找覆盖t的子串的时候就不用实际在s中从0到s.size()-1慢慢挪了，相当于把不属于t串的字符直接一下子跳过。在s串长度远大于t的时候能节省大量时间，这个写法有时间再补吧。。2019年11月13日 22:19:10

 class Solution {
 public:
     string minWindow(string s, string t) {
         if(s.empty() or t.empty()){
             return string();
         }
         map<char,int> dic,cur_dic;
         for(const char& c:t){
             dic[c]+=;
         }
         int le=,ri=,min_len=INT_MAX,cnt=,t_len=t.size();
         string res="";
         while(ri<s.size()){
             // cout<<le<<" "<<ri<<" "<<s.substr(le,ri-le)<<" "<<cnt<<endl;
             while(ri<s.size() and cnt<t_len){
                 if(dic.count(s[ri])>){
                     if(dic[s[ri]]>cur_dic[s[ri]]){
                         cnt++;
                     }
                     cur_dic[s[ri]]++;
                 }
                 ++ri;
             }
             if(cnt!=t_len){
                 return res;
             }
             while(dic.count(s[le])== or dic[s[le]]<cur_dic[s[le]]){
                 if(dic.count(s[le])!=){
                     cur_dic[s[le]]--;
                 }
                 ++le;
             }
             if(ri-le<min_len){
                 min_len=ri-le;
                 res=s.substr(le,ri-le);
             }
             cur_dic[s[le]]--;
             ++le;
             cnt--;
         }
         return res;
     }
 };

 class Solution {
 public:
     string minWindow(string s, string t) {
         if(s.empty() or t.empty()){
             return string();
         }
         map<char,int> dic,cur_dic;
         for(const char& c:t){
             dic[c]+=;
         }
         int le=,ri=,min_len=INT_MAX,cnt=,t_len=t.size();
         string res="";
         while(ri<=s.size()){
             // cout<<le<<" "<<ri<<" "<<s.substr(le,ri-le)<<" "<<cnt<<endl;
             char c=s[ri];
             ++ri;
             if(dic.count(c)){   //匹配
                 cur_dic[c]+=;
                 if(dic[c]>=cur_dic[c]){
                     ++cnt;
                 }
                 while(){   //有重复匹配的，一直右移左边界
                     while(dic.count(s[le])==){    //跳过开头多余字符
                         ++le;
                     }
                     if(dic[s[le]]<cur_dic[s[le]]){
                         cur_dic[s[le]]-=;
                         ++le;
                     }
                     else{
                         break;
                     }
                 }
                 while(dic.count(s[le])==){
                     ++le;
                 }
                 if(cnt==t_len and ri-le<min_len){
                     cout<<s.substr(le,ri-le)<<endl;
                     min_len=ri-le;
                     res=s.substr(le,ri-le);
                 }
             }
             else{   //不匹配
                 ;
             }
         }
         return res;
     }
 };

可以看到两种解法时间并不算快，因为是遍历了s的全部字符。

159. 至多包含两个不同字符的最长子串

 class Solution {
 public:
     int lengthOfLongestSubstringTwoDistinct(string s) {
         map<char,int>dic;
         int le=,ri=,cnt=,s_len=s.size(),max_len=;
         while(ri<s_len){
             if(cnt==){
                 if(dic.count(s[ri])){   //是之前的两个字符之一，直接添加
                     dic[s[ri]]++;
                     ++ri;
                 }
                 else{   //不属于之前的两个字符
                     while(dic[s[le]]>){    //找最左侧元素出现次数为1的
                         dic[s[le]]-=;
                         ++le;
                     }
                     dic.erase(s[le++]);   //把这个出现次数为1的删了
                     dic[s[ri]]++;
                     ++ri;
                 }
             }
             else{   //cnt=0 or 1
                 if(dic.count(s[ri])==){
                     ++cnt;
                 }
                 dic[s[ri++]]+=;
             }
             max_len=max(max_len,ri-le);
         }
         return max_len;
     }
 };

209. 长度最小的子数组

这题不解释了阿，前面会了就会。

A:

 class Solution {
 public:
     int minSubArrayLen(int s, vector<int>& nums) {
         int le=,ri=,len=nums.size(),min_len=INT_MAX,cur_sum=;
         while(ri<len){
             cur_sum+=nums[ri++];
             if(cur_sum>=s){
                 while(cur_sum-nums[le]>=s){
                     cur_sum-=nums[le];
                     ++le;
                 }
                 min_len=min(min_len,ri-le);
             }
         }
         return min_len!=INT_MAX?min_len:;
     }
 };

239. 滑动窗口最大值

这题没做出来，用的是一个新的东西：双端队列。
我先说一下我做时候的想法：由于这题的窗口是固定长度，每次要找窗口内的最大值。那最naive的方法就是维护长度k的窗口，遍历(n-k)*k次就行，复杂度O(nk)。然后我又考虑可以用堆（c++优先队列）维护窗口，这样复杂度可以减少为O(nlogk)。但问题是假如前一个窗口的最大值是首元素，窗口后移一位后，怎么把之前最大值删掉。更新：这里可以用索引堆，专门去研究了一下索引堆怎么写。 但这个写法就不写了。
下面只放一个双端队列的做法：
思路是维护一个双端队列（两边都可以push和pop的队列），其大小为k。然后关键要始终维持的性质是该队列为非递增序，即x1>=x2>=x3>=…>=xk。当然队列不存储值，而是存储对应nums数组中的下标。然后每次窗口右移一位，每次要考察队首（队列左侧）的值是否已经越界。即当前窗口右侧到达i位置，那么最左侧位置不能小于i+1-k，否则整个窗口长度就超过k了，这就不符题意了。而且每次滑动窗口只需要检验最左侧，原因有二：1. 我们push索引到窗口里的时候是从左到右遍历nums来的，故只要最左侧不越界，窗口其它位置一定不越界。2. 由于滑动窗口一次只挪一位。
上面一段写成代码就是：

if(!window.empty() and window.front()<i-k+1){
                window.pop_front();
            }

考察最左侧索引后，剩下的工作就是push新移进窗口的右边界（新的边界）。
同最开始建立初始窗口一样，我们要保持非增序。小于右边界的都pop，最后把右边界push进来，就完成了一轮窗口的移动。对应的代码如下：

while(!window.empty() and nums[window.back()]<nums[i]){
                window.pop_back();
            }
            window.push_back(i);

这样完成一轮移动后，窗口内最大的元素就是左边界作为索引p对应的nums中的元素nums[p]。
下面我简单证明一下这个算法的有效性。
1.对于任意长度k的子数组，我们对左边界是否越界的考察保证了当前窗口不会包含比该长度k子数组更多的元素。
2.既然我们的窗口包含元素比实际长度k的子数组更少，那有没有可能会略掉某个该子数组中的最大值没有统计呢？假设实际子数组是i到i+k-1，那么上次的窗口遍历的是i-1到i+k-2的子数组，并假设上次的窗口window1中的元素都满足不越界（相当于数学归纳法，假设i-1的情况成立，只要推得i的情况成立，并且i==1时情况成立结论就成立，而这题我们第一轮初始的窗口显然是正确的）。1. 假设上次的窗口是window1。若window1包含i-1，则当前这轮遍历开始时，会考察左边界是否越界，此时会把i-1剔除掉，再push进来i+k-1号。故这种情况当前窗口会输出正确结果。
2. 假设上次的窗口window1不包含i-1，那么显然这轮遍历开始时，左边界肯定不会越界，因为左边界最多也就是i，i本来就应该在当前窗口内的。故这种情况也会输出正确结果。

 class Solution {
 public:
     vector<int> maxSlidingWindow(vector<int>& nums, int k) {
         if(k< or nums.empty()){
             return vector<int>();
         }
         deque<int> window;
         int siz=nums.size();
         vector<int> res;
         //初始化双端队列
         for(int i=;i<k;++i){
             while(!window.empty() and nums[window.back()]<nums[i]){
                 window.pop_back();
             }
             window.push_back(i);
         }
         res.push_back(nums[window.front()]);
         for(int i=k;i<siz;++i){
             if(!window.empty() and window.front()<i-k+){
                 window.pop_front();
             }
             while(!window.empty() and nums[window.back()]<nums[i]){
                 window.pop_back();
             }
             window.push_back(i);
             res.push_back(nums[window.front()]);
         }
         return res;
     }
 };

567. 字符串的排列

这题其实只要前面题都做了，就一模一样的解法套就完事了。然后我看评论中很多用vector代替map来做字符记录的。这种做法是利用char对应ascii码0到128的特点，开一个128大小的vector来模拟map，比如当前有一个字母a（ascii好像是97吧），那就把vector[97]+1，到时候查询字母a的频数也直接来查vector[97]就好了。滑窗还是正常的滑，并且这题还是固定大小的窗口，所以比较简单。用map会慢一些，因为首先map查询O(logn)，比不上数组下标的O(1)。另外遍历到非s1中字符的时候，我的做法将当前记录的map清零，这个可能也比较费时。用vector模拟map的解法我偷懒没写，想看的就点进评论区看看吧。。。

 class Solution {
 public:
     bool checkInclusion(string s1, string s2) {
         if(s2.size()<s1.size()){
             return false;
         }
         int s2_siz=s2.size(),s1_siz=s1.size();
         int le=,ri=,cnt=;
         map<char,int> dic;
         for(char c:s1){
             dic[c]+=;
         }
         map<char,int>cur_dic;
         while(ri<s2_siz){
             char c=s2[ri++];
             if(dic.count(c)){  //匹配
                 ++cnt;
                 cur_dic[c]++;
                 while(dic[c]<cur_dic[c]){
                     cur_dic[s2[le]]--;
                     ++le;
                     --cnt;
                 }
                 if(cnt==s1_siz){
                     return true;
                 }
             }
             else{   //不匹配
                 cnt=;
                 cur_dic.clear();
                 le=ri;
             }
         }
         return false;
     }
 };

727. 最小窗口子序列

这题我一开始是这样思考的：要找S的最短子串满足T中字符按序存在于该子串内。那显然就不能像之前的题目那样用map了，因为此题多了出现顺序的要求。那么就先找第一个符合条件的子串再看看怎么继续下去。假如目前找到了0开始到i结束的子串包含T的子序列，那么从0开始的最短子串就是这个了。那下面把左边界右移一位再从1开始找？这样的复杂度不就是n^2了吗。然后我就卡在这了。
憋了半天还是去看评论区了，大致看到了两种解法：
第一种：评论链接和我的基本思路是一致的，但作者用了一种特别的优化。关键思路：如果当前我们找到了一个满足条件的子串，索引i到j，即i处对应T[0]，j处对应T[-1]。
那么在该子串中满足条件的最短子串就是从右到左倒序依次查找T[-1],T[-2],T[-2]…到T[0]的子串（因为这个子串肯定不比j-i+1长，所以是最短的没毛病）。咋证明呢，很简单：对于i到j的串，因为最后一个元素是T[-1]，而且这个元素只出现了这一次，那么最终的子串必须包含它。所以我们从末尾倒着往前查找T中的字符，最终找到的子串就一定是当前i到j串中满足条件的最短子串。比较遗憾的是，作者的代码格式不是很清晰，故我又自己写了一份在下面，思路完全参照作者。这个时间应该是最优O(n)，最差O(n^2)，比如S是100个字符a，T是aa，每次循环相当于只移动了一位。

 class Solution {
 public:
     string minWindow(string S, string T) {
         //找S的最短子串w，w中要包含T中的全部字符，并按顺序出现。
         if(S.size()<T.size()){
             return "";
         }
         int s_size=S.size(),t_size=T.size(),le=,ri=,cnt=,_start=,_end=INT32_MAX;
         while(ri<s_size){
             if(S[ri]==T[cnt]){//匹配
                 ++cnt;
                 if(cnt==t_size){//找到符合条件的子串[le,ri]
                     le=ri;
                     while(cnt){//从ri倒序查找T[-1],T[-2]..到T[0]
                         if(S[le]==T[cnt-]){
                             --cnt;
                         }
                         --le;
                     }
                     //此时cnt==0，S[le+1]==T[0]
                     ++le;
                     if(ri-le+<_end-_start){
                         _start=le;
                         _end=ri+;
                     }
                     ++le;
                     ri=le-;
                 }
                 ++ri;
             }
             else{
                 ++ri;
             }
         }
         return _end==INT32_MAX?"":S.substr(_start,_end-_start);
     }
 };

然后我又看到一种动态规划解法，tql，没想到。
思路是二维dp，dp[i][j]存储T截止到j的字符串t1，S截止到i包含t1子序列的左边界索引，这个时间是稳定的O(n^2)。

 class Solution {
 public:
     string minWindow(string S, string T) {
         if(S.size()<T.size()){
             return "";
         }
         int s_size=S.size(),t_size=T.size();
         vector<vector<int>>dp(t_size,vector<int>(s_size,-));
         int le=,ri=INT32_MAX;
         //dp[i][j]存储S截止j的字符串s1，T截止i的字符串t1，s1包含t1的子序列的左索引
         if(S[]==T[]){
             dp[][]=;
         }
         for(int i=;i<s_size;++i){
             if(S[i]==T[]){
                 dp[][i]=i;
             }
             else if(dp[][i-]!=-){
                 dp[][i]=dp[][i-];
             }
         }
         for(int i=;i<t_size;++i){
             for(int j=i;j<s_size;++j){
                 if(S[j]==T[i]){
                     dp[i][j]=dp[i-][j-];
                 }
                 else{
                     dp[i][j]=dp[i][j-];
                 }
             }
         }
         // for(auto row:dp){
         //     for(auto col:row){
         //         cout<<col<<" ";
         //     }cout<<endl;
         // }
         for(int i=t_size;i<s_size;++i){
             if(dp[t_size-][i]!=- and i-dp[t_size-][i]<ri-le){
                 le=dp[t_size-][i];
                 ri=i;
             }
         }
         return ri==INT32_MAX?"":S.substr(le,ri-le+);
     }
 };

完结撒花！2019年11月17日 00:46:57