【每日leetcode】滑动窗口算法总结

参考自：vx:https://mp.weixin.qq.com/s/vM6ha7Wwp_EkfRMfLg1dZQ

前言科普：什么是滑动窗口算法

滑动问题包含一个滑动窗口，它是一个运行在一个大数组上的子列表，该数组是一个底层元素集合。

假设有数组 [a b c d e f g h ]，一个大小为 3 的 滑动窗口 在其上滑动，则有：

[a b c]
  [b c d]
    [c d e]
      [d e f]
        [e f g]
          [f g h]

一般情况下就是使用这个窗口在数组的 合法区间 内进行滑动，同时 动态地 记录一些有用的数据，很多情况下，能够极大地提高算法地效率

1. 滑动窗口最大值

给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口 k 内的数字。滑动窗口每次只向右移动一位。

返回滑动窗口最大值。
示例:

输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
输出: [3,3,5,5,6,7] 
解释: 

  滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

注意：
你可以假设 k 总是有效的，1 ≤ k ≤ 输入数组的大小，且输入数组不为空。
进阶：
你能在线性时间复杂度内解决此题吗？

解析：

利用一个 双端队列，在队列中存储元素在数组中的位置， 并且维持队列的严格递减,，也就说维持队首元素是 最大的 ，当遍历到一个新元素时, 如果队列里有比当前元素小的，就将其移除队列，以保证队列的递减。当队列元素位置之差大于 k，就将队首元素移除。

c++代码：

deque的一些用法：
deque两端都能够快速插入和删除元素，但是在头部插入元素和使用insert()方法在中间插入元素都不会新增元素，而是会覆盖原来的元素
deq.front()：返回第一个元素的引用。
deq.back()：返回最后一个元素的引用。
deq.push_front(x)：把元素x插入到双向队列的头部。
deq.pop_front()：弹出双向队列的第一个元素。
deq.push_back(x)：把元素x插入到双向队列的尾部。
deq.pop_back()：弹出双向队列的最后一个元素。

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> res;
        if(nums.empty())
            return res;
        deque<int> q;//存储下标
        for(int i=0;i<nums.size();i++)
        {
            while(!q.empty()&&nums[q.back()]<nums[i])
            {
                q.pop_back();
            }
            q.push_back(i);
            if(q.front()==i-k)//满了
            {
                q.pop_front();
            }
            if(i>=k-1)
            {
                res.push_back(nums[q.front()]);
            }
        }
        return res;
    }
    
};

无重复字符的最长子串

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:
输入: “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:
输入: “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。

思路：

当出现重复字符时，抛弃重复出现的字符前一次出现的位置，把新的子串开始位置设置为其+1来统计子串长度，最后得出最长的子串长度。
dict存的是每个字符最后一次出现的位置，start是无重复字符串开始的位置

c++代码

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int size = s.size();
        vector<int> dict(256,-1);
        int maxlen = 0;
        int start = -1;
        for (int i=0;i<size;i++) {
            if (dict[s[i]] > start) {
                start = dict[s[i]];
            }
            dict[s[i]] = i;
            maxlen = max(maxlen, i - start);
        }
        return maxlen;
    }
};

长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组。如果不存在符合条件的连续子数组，返回 0。
示例:
输入: s = 7, nums = [2,3,1,2,4,3]
输出: 2
解释: 子数组 [4,3] 是该条件下的长度最小的连续子数组。
进阶:
如果你已经完成了O(n) 时间复杂度的解法, 请尝试 O(n log n) 时间复杂度的解法。

解析：

定义两个指针 left 和 right ，分别记录子数组的左右的边界位置。

（1）让 right 向右移，直到子数组和大于等于给定值或者 right 达到数组末尾；
（2）更新最短距离，将 left 像右移一位, sum 减去移去的值；
（3）重复（1）（2）步骤，直到 right 到达末尾，且 left 到达临界位置

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        if(nums.empty())
            return 0;
        int n=nums.size();
        int left=0,right=-1;
        int sum=0;
        int result=n+1;
        while(left<n)
        {
            if(right+1<n&&sum<s)
            {
                right++;
                sum=sum+nums[right];
            }
            else
            {
                sum=sum-nums[left];
                left++;
            }
            if(sum>=s)
            {
                result=min(right-left+1,result);
            }
        }
        if(result==n+1)//所有的nums都加一起都不够s
            return 0;
        return result;
    }
};