leetcode刷题记录——长度最小的子数组（ 滑动窗口）

leetcode刷题记录——长度最小的子数组（滑动窗口）

——参考代码随想录和力扣顺序刷题（https://programmercarl.com/）

---

209. 长度最小的子数组（中等）

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

示例 1：
输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

示例 2：
输入：target = 4, nums = [1,4,4]
输出：1

示例 3：
输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

思路：

• 快慢指针（滑动窗口）
• 窗口的起始位置如何移动：如果当前窗口的值大于目标值target了，窗口就要向前移动了（也就是该缩小了）。
• 不用for用while的原因：避免fastIndex自增导致重复加数字；

代码1：自己写的

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int slowIndex = 0;
        int fastIndex = 0;
        int result = INT32_MAX;
        int length = 0;
        int sum = nums[0]; 
        while(slowIndex <= fastIndex) {
            if(sum >= target) {
                length = fastIndex - slowIndex + 1;
                result = min(result,length);
                sum -= nums[slowIndex];
                slowIndex++;
            }
            else {
                fastIndex++;
                if(fastIndex <= nums.size() - 1)
                sum += nums[fastIndex];
                else break;
            }
        }
        return result == INT32_MAX ? 0 : result;
    }
};

代码2：（代码随想录）

• 通过j（遍历整个数组的）和i（用来调整窗口的起始位置）来进行移动；

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int result = INT32_MAX;
        int sum = 0; // 滑动窗口数值之和
        int i = 0; // 滑动窗口起始位置
        int subLength = 0; // 滑动窗口的长度
        for (int j = 0; j < nums.size(); j++) {
            sum += nums[j];
            // 注意这里使用while，每次更新 i（起始位置），并不断比较子序列是否符合条件
            while (sum >= s) {
                subLength = (j - i + 1); // 取子序列的长度
                result = result < subLength ? result : subLength;
                sum -= nums[i++]; // 这里体现出滑动窗口的精髓之处，不断变更i（子序列的起始位置）
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result;
    }
};

时间复杂度：O(n)

• 不要以为for里放一个while就以为是O(n^2)啊， 主要是看每一个元素被操作的次数，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n 也就是O(n)。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/minimum-size-subarray-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

904. 水果成篮（中等）

题目意思：找出一个最大的连续数组，使得这个数组中只有两个整数。

思路：

• 滑动窗口双指针

• 设置basket数组，表示篮子，表示两种不同的水果。

• 如果遇到新品种，则换掉basket[0]，并从当前位置往前找，直到和basket[0]不相同为止。这样的一个循环表示一个最大的数组，然后进行比较。

• 难点：确定数组里面的个数。

  • 测试样例：

  fruits = [3,3,3,1,2,1,1,2,3,3,4]
  fruits = [0,1,6,6,4,4,6]
  fruits = [0,1,0,2]
  

① 对应：处理开始连续为同一个数字的数组；

② 对应：slowindex位置不一定是fastindex - 1；所以要从后往前找；

③ 对应：有可能basket[0]和fastindex-1相同，但中间夹杂其他数字；

代码：

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        if(fruits.size() == 1) return 1;
        if(fruits.size() == 2) return 2;
        int slowIndex = 0;
        int length = 0;
        int result = INT32_MIN;
        vector<int> basket(2,0);
        basket[0] = fruits[0];
        basket[1] = fruits[1];
        for(int fastIndex = 1;fastIndex<fruits.size();fastIndex++) {
            if(fruits[fastIndex] != basket[0] && fruits[fastIndex] != basket[1]) {
                basket[0] = fruits[fastIndex-1];
                basket[1] = fruits[fastIndex];
                int cnt = fastIndex - 1;
                while(cnt >= 0) {
                    if(fruits[cnt] == basket[0] || fruits[cnt] == basket[1]) cnt--;
                    else break;
                }
                slowIndex = cnt + 1;
            }
            length = fastIndex - slowIndex + 1;
            result = max(length,result);
        }
        return result;
    }
};

---

76. 最小覆盖子串（困难）

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 “” 。

注意：

• 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
• 如果 s 中存在这样的子串，我们保证它是唯一的答案。

示例 1：
输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"

思路：

• 滑动窗口+哈希表
• 滑动窗口：双指针从头开始向前
  • 难点：清楚leftIndex指针停止和开始的条件
  • leftIndex开始：check(true)：表示s当前（substr.[leftIndex,rightIndex]）中包含所有t中的元素
    • check()如何实现：用哈希表，当每次能在t的哈希表中找到时，遍历s的哈希表，看是否所有t均在s的哈希表中；
  • leftIndex结束：碰到第一个check(false)的字母时停止；

代码：

class Solution {
public:
    unordered_map <char, int> tar, str;

    bool check() {
        for (const auto &p: tar) {
            if (str[p.first] < p.second) {
                return false;
            }
        }
        return true;
    }

    string minWindow(string s, string t) {
        int minlength = INT_MAX;
        int curleft = -1;
        for(int i=0;i<t.length();i++) {
            tar[t[i]]++;
        }
        int leftIndex = 0;
        int rightIndex = 0;
        while(rightIndex < s.length()) {
            if(tar.find(s[rightIndex]) != tar.end()) {
                str[s[rightIndex]]++;
                if(check()) {
                    while(check() && leftIndex < s.length()) {
                        str[s[leftIndex]]--;
                        leftIndex++;
                    }
                    if(rightIndex-leftIndex+2 < minlength) {
                        minlength = rightIndex-leftIndex+2;
                        curleft = leftIndex - 1;
                    }
                }
                rightIndex++;
            }
            else {
                rightIndex++;
            }
        }
        return curleft == -1 ? string() : s.substr(curleft, minlength);
    }
};

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/minimum-window-substring
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。