算法-滑动窗口

算法概念：

滑动窗口，与双指针类似，也是使用两个指针进行移动遍历数组处理，也可以说时双指针中的一个特殊类型，因为左右指针同向移动，左右指针中间所夹的区域像一个窗口一样移动，所以称为滑动窗口。算法思想：再暴力枚举的基础上根据单调性来解决问题。或者其他规律

实际操作：

以第一个例题举例，首先需要两个指针，一个指针入窗口(right)，一个指针出窗口(left),以及right遍历的所需条件。

第一步：依据题意，单位元素入窗口，

第二步：依据题意，并且判断是否要出窗口。用while循环，一直满足就一直出窗口。不满足返回第一步。

第三步：更新结果，更新结果要依据题意，在适当位置（满足题目条件时）更新结果。

第一个例题是在出窗口前时，满足条件，更新结果。

why（重点）：

为什么用滑动窗口？问题求解：是一个连续区间问题。例如：所需要的return/answer，为一段区间练习

209. 长度最小的子数组 - 力扣（LeetCode）

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int n=nums.size();
        int sum=0;
        int len=INT_MAX;
        int left=0,right=0;
        while(right<n){
            sum+=nums[right];//入窗口
            while(sum>=target) {//此时已经找出固定left的长度最小的连续子数组
                len=min(len,right-left+1);
                sum-=nums[left++];
            }
            right++;//必须在更新结果之后出
        }        
        return len == INT_MAX ? 0 : len;
    }
};

3. 无重复字符的最长子串 - 力扣（LeetCode）

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int hash[128]={0};//26个字母只用26个位置，也可以用位图，ascII码只有128个
        int count=0;//记录有效字符的长度
        int len=0;
        for(int left=0,right=0;right<s.size();){
            //入窗口
            hash[s[right]]++;
            while(hash[s[right]]>=2){//出窗口
                hash[s[left]]--;
                count--;
                left++;
            }
            len=max(len,right-left+1); //更新结果
            right ++;
            
        }
        return len;
    }
};

1004. 最大连续1的个数 III - 力扣（LeetCode）

class Solution {
public:
    int longestOnes(vector<int>& nums, int k) {
        int count=0;//每次入窗口要统计0的个数不超过K
        int len=0;
        for(int left=0,right=0;right<nums.size();){
            if(nums[right]==0) count++;
            while(count>k){//出窗口
                if(nums[left]==0) count--;
                left++;
            }
            len=max(len,right-left+1);
            right++;
        }
        return len;
    }
};

1658. 将 x 减到 0 的最小操作数 - 力扣（LeetCode）

class Solution {
public:
    int minOperations(vector<int>& nums, int x) {
        //转换成求中间最大连续区间数组，其和要求是target=数组总和-x
        int n=nums.size();
        long long sum=0;//sum超过int类型上限
        for(int val:nums){
            sum+=val;
        }
        int target=sum-x;
        if(target<0) 
        return -1;//出现x大于nums总和
        sum=0;
        int max_len=-1;
        for(int left=0,right=0;right<n;){
            sum+=nums[right];//入窗口后right
            //if(sum==target) max_len=max(max_len,right-left+1);//放在这里的话，出窗口后满足结果但是无法更新结果，因为必然会入窗一次。
             while(target<sum){
                sum-=nums[left++];
            }
            if(sum==target) max_len=max(max_len,right-left+1);
            right++;
        }
        if(max_len==-1){return -1;}//x小于任何nums中任何一个元素
        return n-max_len;
    }
};

904. 水果成篮 - 力扣（LeetCode）

class Solution {//转换成数学逻辑：求仅包含两种数字的连续最大区间，区间——》滑动窗口
public:
    int totalFruit(vector<int>& fruits) {
        int ret = -1;
        int kind = 0;//标记种类
        int n = fruits.size();
        //判断是否是已经采摘的种类，用一个hash表或者位图,这里用数组模拟
        vector<int> count = { 0 };
        count.resize(n);
        for (int left = 0, right = 0; right < n;) {
                if (count[fruits[right]] == 0) //更新kind种类
                    kind++;
                count[fruits[right]]++;//此种类的个数，用以判断kinds的操作
            
            while (kind > 2) {//出窗口
                count[fruits[left]]--;
                if (count[fruits[left]] == 0) {
                    kind--;
                }
                left++;
            }
            //更新结果
            ret = max(ret, right-left+1);

            right++;
        }
        return ret;
    }
};

 438. 找到字符串中所有字母异位词 - 力扣（LeetCode）(难)

class Solution {//找到所有异位词，关键在于判断两串如何判断，
public:
    vector<int> findAnagrams(string s, string p) {
        vector<int> ret;

        int vaild=0;//有效字符的个数
        int hash2[26]={0};//统计窗口中的字符

        int hash1[26]={0};//模拟hash,统计p中字符的个数
        for(char ch:p){
            hash1[ch-'a']++;
        }
        for(int left=0,right=0;right<s.size();){
            char in= s[right];
            if(++hash2[in-'a']<=hash1[in-'a']) vaild++;
            while(right-left+1>p.size()){
                 char out= s[left];
                if(hash2[out-'a']-- <= hash1[out-'a']) vaild--;
                left++;
            }
            if(vaild==p.size()) ret.push_back(left);
            right++;
        }
        return ret;
    }
};

30. 串联所有单词的子串 - 力扣（LeetCode）

不同颜色表示不同情况，一共i从0~len-1种情况。

class Solution {//上题是找char的异或词，这局是找string的异或词,所以移动步长是len，我们将s分为len种情况依次遍历一遍。
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        vector<int> ret;
        unordered_map<string,int> hash1;//建立words的hash表，用于统计word字符串的个数
        for(string val:words){
            hash1[val]++;
        }
        int len =words[0].size();int n=words.size();
        for(int i=0;i<len;i++){
            int vaild=0;//有效字符串的个数
            unordered_map<string,int> hash2;//统计窗口内的字符串，
            for(int left=i,right=i;right+len-1<s.size();right+=len){//进行滑动窗口操作
                //入窗口
                string in=s.substr(right,len);
                hash2[in]++;
                if(hash1.count(in)&&hash2[in]<=hash1[in]) vaild++;
                while(right-left+len>len*n){
                    string out=s.substr(left,len);
                    if(hash1.count(out)&&hash2[out]<=hash1[out]) vaild--;
                    hash2[out]--;
                    left+=len;//left移动***
                }
                if(vaild==n) ret.push_back(left);
            }
        }
        return ret;
    }
};

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

本题更新结果具体问题具体分析，因为出窗的条件是满足问题目标，所以需要在出窗满足时，提前更新结果，然后观察其他问题，出窗条件为不满足问题目标（通常是大于/超过）。所以更新结果不用再出窗满足时。

class Solution {
public:
    string minWindow(string s, string t) {
        
        int hash1[128]={0};int count=0;//hash存储各个字符的个数，用以统计有效字符的个数，count存储总个数
        for(char ch:t){
            hash1[ch]++;
            count++;
        }
        int hash2[128]={0};int vaild=0;

        int min_len=INT_MAX;int begin=-1;
        for(int left=0,right=0;right<s.size();right++){
            hash2[s[right]]++;
            if(hash1[s[right]]>0&&hash2[s[right]]<=hash1[s[right]]) vaild++;
             if(vaild==count&&right-left+1<min_len){//更新结果
                min_len=right-left+1;
                begin=left;
            }
            while(vaild==count){//实现问题出窗口，其他类型为超过问题出结果
                char out=s[left];
                if(hash1[out]>0&&hash2[out]<=hash1[out]) vaild--;
                hash2[out]--;
                left++;
                if(vaild==count&&right-left+1<min_len){//更新结果
                min_len=right-left+1;
                begin=left;
                }
            }
           
            
        }
        if(begin==-1) return "";
        return s.substr(begin,min_len);
        
    }
};