Leetcode- 滑动窗口类型题总结

目录

Sliding window--分为滑动窗口和固定窗口

滑动窗口

固定窗口

---

Sliding window--分为滑动窗口和固定窗口

滑动窗口题目一般是在数组、链表、字符串等线性结构上进行操作，比如找最长的子字符串、最短的子字符串等等

 

判断是否需要用滑动窗口法：

对象是数组、链表、字符串等线性结构

题目要求求具有最短、最长、或固定长度的子序列

滑动窗口问题一般具有以下结构：

先移动右窗口边界，逐步扩大右窗口，直到达到临界条件，然后循环移动左窗口，并更新问题答案，直到又不满足临界条件需要移动右窗口边界为止；如此循环

而且一般右窗口通过for循环来实现移动，左窗口通过if或者while循环来实现

leetcode典型例题：

滑动窗口

1.Minimum Size Subarray Sum

2. Longest Substring Without Repeating Characters

3.Fruit Into Baskets

4. Get Equal Substrings Within Budget
如下例题：

分析：对象是数组，要求找出最小长度的连续子数组，而子数组之和大于给定的数s

我们可以先扩大右边界，直到数组和达到临界条件（即大于等于s）,然后移动左边界，并更新最小长度子数组

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        
        int left = 0, right = 0;
        int res = INT_MAX;
        int n = nums.size();
        int count = 0;
        for(right = 0; right < n; right++)
        {
            count += nums[right];
            while(count >= s)
            {
                res = min(right-left+1,res);
                count -= nums[left];
                left++;
            }
        }
        
        return res == INT_MAX ? 0 : res;
        
    }
};

分析：找最长的无重复字符的子字符串，用滑动窗口，先移动右窗口直到到达临界条件（出现重复子符，可以用map记录）;一旦出现重复字符，就需要移动左窗口，直到窗口内没有重复字符即可；所以左窗口需要移动到上一次出现重复字符的下一位

比如  "cbraiuabc"

一旦发现a重复，我们需要将左窗口移动到a的下一位i;移动到下一位i之后，字符串中再出现b就不再算是窗口内的重复，但是map中却记录了第一次出现的b，所以我们要比较出现的重复字符的位置与左窗口的位置大小，如果在左窗口左边，则不算重复，但是如果在左窗口右边，则左窗口需要移动至该位置+1处

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        
        int left = 0, right = 0;
        int n = s.size();
        unordered_map<char,int> map;
        int res = 0;
        for(right = 0; right < n; right++)
        {
            
            if(map.find(s[right]) != map.end())//如果发现map中有记录，则需要看是否需要移动left的位置
            {
                res = max(res,right - left);
                left = max(left,map[s[right]]+1);//记录字符出现在左窗口右边，则需要移到该位置+1处，
                // 出现在左窗口左边，即当前窗口内无重复字符不用移动
            }
            map[s[right]] = right;
            
        }
        res = max(res,right-left);
        return res;
    }
};

 

固定窗口

5.Permutation in String

6.Grumpy Bookstore Owner

设固定窗口是n，

固定窗口右窗口到终点的位置至少要是n，因为右窗口是左窗口的右边界

先计算出初始窗口内的目标值，然后开始移动

之后右窗口的滑动通过 +n来完成,其他和滑动窗口类似

 

 

 

分析：因为在s2中找子数组是否与s1 是全排列关系，所以该子数组需要和s1的长度一致，然后在s2中滑动，知道该窗口内的字母和s1中的字母及个数完全一致

class Solution {
public:
    bool checkInclusion(string s1, string s2) {
    
        //固定窗口大小不需要通过滑动确定，直接确定即可
        int n1 = s1.size();//固定窗口大小为n1
        int n2 = s2.size();
        if(n1 > n2)
        {
            return false;
        }
        
        vector<int> vec1(26,0), vec2(26,0);
        
        for(int i = 0; i < n1; i++)//初始窗口内的字母个数以及s1参考的字母个数
        {
            vec1[s1[i]-'a']++;
            vec2[s2[i]-'a']++;
        }
        if(vec1 == vec2)
        {
            return true;
        }
        //开始移动固定窗口
        for(int i = 0; i < n2-n1; i++)
        {
            vec2[s2[i]-'a']--;//左窗口右移
            vec2[s2[i+n1]-'a']++;//右窗口右移，保持窗口长度不变
            if(vec1 == vec2)
            {
                return true;
            }
        }
        return false;
    }
};

class Solution {
public:
    int maxSatisfied(vector<int>& customers, vector<int>& grumpy, int X) {
    
        //固定窗口在grumpy数组上滑动，然后计算此时总体的客户满意度
        int res = 0;
        int n1 = grumpy.size()-X;
        int left = 0, right = 0;
        
        int sat = 0;
        for(int i = 0; i < grumpy.size(); i++)
        {
            if(i < X)
            {
               sat += customers[i]; 
            }
            else
            {
                if(grumpy[i] == 0)
                {
                    sat += customers[i];
                }
            }
        }
        
        res = sat;
        
        for(right = 0; right < n1; right++)
        {
            if(grumpy[right+X] == 1)//原来是1，则需要加上，原来是0表示已经加上
            {
                sat += customers[right+X];
            }
            
            if(grumpy[left] == 1)//原来是1表明多加了，原来是0表明应该加上
            {
                sat -= customers[left];
                left++;
            }
            else
            {
                left++;
            }
            
            res = max(res,sat);
            
        }
        return res;
    }
};