滑动窗口的知识

209.长度最小的子数组（下面这两道题的基础）

904.水果成篮

76.最小覆盖字串（我认为是有难度的一道题）

对于209题

我最初想的是暴力解决的方法，时间复杂度为O(N^2),但是leetcode提示超出时间限制。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int min = INT32_MAX;
        int res = 0;
        int sum = 0;
        for(int i = 0;i<nums.size();i++)
        {
            sum = 0;
            for(int j = i;j<nums.size();j++)
            {
                sum += nums[j];
                if(sum >= target)
                {
                    res = j - i + 1;
                    min = min < res? min:res;
                    break; //因为我们是找符合条件最短子序列，所以一旦符合条件就break
                }
                

            }
        }
        return min == INT32_MAX? 0: min;
    }

};

我第一开始的判读就是用的简单的if判断语句而是不是什么，三目运算符，其实都一样，但是三目运算符更加简洁一点。

经过查找这种类型题可以用滑动窗口：

所谓滑动窗口，就是不断调整子序列的起始位置和终止位置，从而得到我们想要结果。

可以这样理解滑动窗口就是双指针的另外一种形式，但是更像是窗口的移动，所以叫做滑动窗口。

窗口内是什么？

窗口内是满足我们条件的连续子数组。

如何移动窗口的起始位置？

对于这题来说，如果连续子数组的值大于s了，窗口就要向前移动了，也就是该缩小了。

如何移动窗口的结束位置？

窗口的结束位置就是遍历数组的指针，窗口的起始位置设为数组的起始位置就可以。

 滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而时间复杂度降为O(n);

 int min = INT32_MAX;

​    int res = 0;

​    int sum = 0;

​    int i = 0;

​    for(int j = 0;j<nums.size();j++)

​    {

​      sum +=nums[j];

​      while(sum >= target)

​      {

​        res = j-i+1;

​        min = min<res?min:res;

​        sum -= nums[i++];

​      }

​    }

​    return min == INT32_MAX? 0: min;

对于904题其实思路也是滑动窗口的一个思路，新建一个unorder_map(uborder_map就是没有顺序的map，所以我们可以把他当作map来看待就行)，这个题思路就是我右指针一直走直到走到unorder_map里面出现3个key值(不同的key值)，然后右指针不动，左指针开始动，动到三个key中其中一个value值为0，把他清除，这样map容器中就只有两个不同的key值，右指针开始动，当我们发现key刚有三个不同值的时候，求出这个距离先当作最大距离，这样右指针遍历完整个数组的时候，就可以求出最大那个距离，也就是收集水果的最大数目。

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        int n = fruits.size();
        unordered_map<int, int> cnt;

        int left = 0, ans = 0;
        for (int right = 0; right < n; ++right) {
            cnt[fruits[right]]++;
            while (cnt.size() > 2) {
                auto it = cnt.find(fruits[left]);
                (it->second)--;
                if (it->second == 0) {
                    cnt.erase(it);
                }
                left++;
            }
            ans = max(ans, right - left + 1);
        }
        return ans;
    }
};

76题对于我来说有难度的，我研究了很久,下面这事代码，这个题的逻辑我都注释在代码当中了，难题就需要反复会看，去思考。

class Solution {
public:
    string minWindow(string s, string t) {
        //如果本身的s就没有t长肯定匹配不到直接返回“”
        if(s.length() < t.length())
        {
            return "";
        }
        //先把t字符串中的元素以及个数放在一个无序map中
        unordered_map<char,int>um_t;
        for(int i = 0;i<t.length();i++)
        {
            um_t[t[i]]++;
        }
        int left = 0;
        int distance = 0;
        string res = s + "initialize a max string";
        unordered_map<char,int>um_s;
        for(int j = 0;j<s.length();j++)
        {
            //将s字符串中的元素以及个数放在一个无序map中
            um_s[s[j]]++;
            //如果s中j位置的元素是t中的，而且元素个数是小于等于t中的就把distance++，证明右指针轨迹逐步符合t的要求
            if(um_t[s[j]] >= um_s[s[j]])
            {
                distance++;
            }
            //这个while语句就是如果s中于t中元素相同，且右指针轨迹中包含的相同元素个数是大于t的，我们要把左指针一步步右移动，使其不能超过t中元素个数
            while(left < j && um_s[s[left]] > um_t[s[left]])
            {
                um_s[s[left++]]--;
            }
            //如果distance等于t字符串的大小，证明右指针到左指针之间包含t字符串所有元素，可以取下这个字串。
            if(distance == t.size())
            {
                if(j -left + 1<res.size())
                {
                    res = s.substr(left,j -left + 1);
                }
            }
        }
          //用三目运算符，判断最小字串。
        return res == s + "initialize a max string"?"":res;
    }
};