leetcode：滑动窗口

目录

1.定长滑动窗口

1.1 几乎唯一子数组的最大和(使用map来计数)

1.2 长度为k子数组中的最大和

2.不定长滑动窗口

2.1 最多k个重复元素的最长子数组

2.2 绝对差不超过限制的最长连续子数组(multiset）

2.3 将x减到0的最小操作数(正难则反 逆向思维)

2.4 统计最大元素出现至少k次的子数组

2.5 乘积小于k的子数组

---

1.定长滑动窗口

1.1 几乎唯一子数组的最大和(使用map来计数)

​

class Solution {
public:
    long long maxSum(vector& nums, int m, int k) {
        long long ans = 0, sum = 0;
        unordered_map
            cnt; //如何把重复的数字算成一个数字，就要用到数组来进行计数了，重复的数字对应的值大于1
        for (int i = 0; i < k - 1; i++) //先求前k-1个数
        {
            sum += nums[i];
            cnt[nums[i]]++;
        }
        for (int i = k - 1; i < nums.size(); i++) //进去一个出来一个，满足k个数
        {
            sum += nums[i];
            cnt[nums[i]]++;
            if (cnt.size() >= m) //判断是否有m个不相同的数
                ans = max(ans, sum);

            int out = nums[i - k + 1];
            sum -= out;
            if (--cnt[out] == 0) //如果只出现1次，可以直接删除
                cnt.erase(out);
        }
        return ans;
    }
};

      这道题让我们求最大的问题，而且是连续非空的子数组，很容易想到滑动窗口，但滑动窗口有定长和不定长两种，题中说长度为k，说明是定长的，要求长度为k的几乎唯一子数组的最大和，我们可以先求前k-1个数，这样之后进来一个出去一个，始终是k个数，题目要求该子数组至少有m个不相同的数，我们怎么记录是否有m个不相同的数呢？我们可以用map来记录有几个不相同的数，同时记录每个数字出现了几次，如果某个子数组有m个不相同的数，就更新答案，之后就要出去一个数，如果出去的这个数只出现了1次，就要直接从map中删除。最后返回答案

1.2 长度为k子数组中的最大和

​

class Solution {
public:
    long long maximumSubarraySum(vector& nums, int k) {
        unordered_map mp;
        long long res = 0, sum = 0;
        for (int i = 0; i < k - 1; i++) {
            sum += nums[i];
            mp[nums[i]]++;
        }
        for (int i = k - 1; i < nums.size(); i++) {
            sum += nums[i];
            mp[nums[i]]++;
            if (mp.size() == k ) res =max(res,sum);//这个已经去重了，只要当mp的大小等于k时，才会更新res的大小，否则说明有重复数字，不更新
            int x = nums[i - k + 1];
            if (--mp[x] == 0) mp.erase(x);//及时清除为0的数字
            sum -= x;
        }
        return res;
    }
};

      这道题也是定长滑动窗口，要求子数组长度为k，且元素各不相同，和上一道题很相似，也要用map，值得注意的是什么时候我们更新答案，只有当map中的元素个数等于k时，说明子数组长度为k，且元素各不相同，这时候更新答案，其他都是不断滑动的过程。

2.不定长滑动窗口

2.1 最多k个重复元素的最长子数组

​

class Solution {
public:
    int maxSubarrayLength(vector& nums, int k) {
        unordered_mapcnt;
        int ans=0,l=0;
        for(int r=0;rk)//如果有元素的出现频率大于k,就要不断左移左指针,直到这个元素的出现频率小于等于k,如果这个元素
                cnt[nums[l++]]--;
            ans=max(ans,r-l+1);
        }
        return ans;
    }
};

     这个没有规定长度，要求满足条件的最长子数组，很明显是不定长滑动窗口的问题。最多k个重复元素说明我们要记录元素出现了几次，一旦超过了k次，我们就要开始滑动，直到子数组没有一个元素的出现频率大于k，否则不断更新答案。

2.2 绝对差不超过限制的最长连续子数组(multiset）

​

class Solution {
public:
    int longestSubarray(vector& nums, int limit) {
        multisetst;//关键在于找每个区间的最大值和最小值，如果遍历寻找，就会超时，所以要找到一个合适的数据结结构
        //我们知道set/multiset/map是有序的，set会去重，所以我们使用multiset
        int l=0;
        int res=0;
        for(int r=0;rlimit)
            {
                st.erase(st.find(nums[l]));
                l++;
            }
            res=max(res,r-l+1);
        }
        return res;
    }
};

      这道题的关键在于求每个区间的最大值和最小值，首先我们要把元素放到multiset中，它不仅不会去重，而且是有序的，改变顺序并不影响答案，这样我们使用两个迭代器rbegin()、begin()分别求逆序第一个元素和正序第一个元素，两者之差就是绝对差，如果大于限制，我们就不断滑动窗口，直到绝对值小于等于限制，更新答案。

2.3 将x减到0的最小操作数(正难则反 逆向思维)

​

class Solution {
public:
    int minOperations(vector &nums, int x) {   //正难则反 逆向思维
        int target = accumulate(nums.begin(), nums.end(), 0) - x;
        if (target < 0) return -1;
        int ans = -1, l = 0, sum = 0, n = nums.size();
        for (int r = 0; r < n; r++) {
            sum += nums[r];
            while (sum > target) sum -= nums[l++]; 
            if (sum == target) ans = max(ans, r - l + 1);
        }
        return ans < 0 ? -1 : n - ans;
    }
};

      这道题借用灵神的思路，正难则反，逆向思维，我们如果维护两个窗口的和，使得和等于x肯定是很麻烦的，那不如我们只维护一个窗口，这个窗口的和要等于整数数组nums的和sum-x，这样只用维护一个区间，不得不说，这个思维太帅了。accumulate函数是用来求某个区间元素的和，0为初始值。

2.4 统计最大元素出现至少k次的子数组

class Solution {
public:
    long long countSubarrays(vector& nums, int k) {
         long long ans=0;
         int mx=*max_element(nums.begin(),nums.end());
         int cnt=0,left=0;        
         for(auto x:nums)
         {
             if(x==mx)cnt++;
             while(cnt==k)
             {
                 if(nums[left]==mx)
                 {
                     cnt--;
                 }
                 left++;
             }
             ans+=left;
         }
         return ans;
    }
};

      这道题我们首先用max_element函数找出数组最大值，然后就对最大值出现的次数进行计数，如果子数组中最大值出现的次数等于k，那么我们就要滑动，寻找下一个满足条件的子数组，如果左端点对应的值等于最大值，cnt--，左端点向右移动，直到cnt!=k，此时更新答案+left，为什么要加left，因为left是cnt==k进入循环向右移动，left++，直到cnt!=k，退出循环得到了，之前的子数组全部满足要求，所以直接加left。

2.5 乘积小于k的子数组

class Solution {
public:
    int numSubarrayProductLessThanK(vector& nums, int k) {
        if(k<=1)return 0;
        int ans=0,mul=1,l=0;
        for(int r=0;r=k)
            {
                 mul/=nums[l];
                 l++;
            }
            ans+=r-l+1;
        }
        return ans;
    }
};

     这道题和上一道题很类似，如果[l，r]区间内子数组的乘积小于k,那么[l+1，r]，[l+2，r]...[r，r]全部小于k，个数为r-l+1，更新答案每次加上r-l+1即可。