长度最小的子数组

长度最小的子数组

**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
 
提示：
1 <= target <= 10^9
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
 

进阶：
如果你已经实现 O(n) 时间复杂度的解法, 请尝试设计一个 O(n log(n)) 时间复杂度的解法。

暴力解法

两个for循环，然后不断的寻找符合条件的子序列。

• 时间复杂度：O(n^2)
• 空间复杂度：O(1)

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int result = INT32_MAX; // 最终的结果
        int sum = 0; // 子序列的数值之和
        int subLength = 0; // 子序列的长度
        for (int i = 0; i < nums.size(); i++) { // 设置子序列起点为i
            sum = 0;
            for (int j = i; j < nums.size(); j++) { // 设置子序列终止位置为j
                sum += nums[j];
                if (sum >= s) { // 一旦发现子序列和超过了s，更新result
                    subLength = j - i + 1; // 取子序列的长度
                    result = result < subLength ? result : subLength;
                    break; // 因为我们是找符合条件最短的子序列，所以一旦符合条件就break
                }
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result;
    }
};

滑动窗口

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

在暴力解法中，是一个for循环滑动窗口的起始位置，一个for循环为滑动窗口的终止位置，用两个for循环 完成了一个不断搜索区间的过程。

那么滑动窗口如何用一个for循环来完成这个操作呢。

首先要思考 如果用一个for循环，那么应该表示 滑动窗口的起始位置，还是终止位置。

如果只用一个for循环来表示 滑动窗口的起始位置，那么如何遍历剩下的终止位置？

此时难免再次陷入 暴力解法的怪圈。

所以 只用一个for循环，那么这个循环的索引，一定是表示 滑动窗口的终止位置。

在本题中实现滑动窗口，主要确定如下三点：

• 窗口内是什么？
• 如何移动窗口的起始位置？
• 如何移动窗口的结束位置？

窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。

窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）。

窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，也就是for循环里的索引。

解题的关键在于 窗口的起始位置如何移动，如图所示：

可以发现滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)暴力解法降为O(n)。

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;
    }
};

最小滑窗模板：给定数组 nums，定义滑窗的左右边界 i, j，求满足某个条件的滑窗的最小长度。

while (j < nums.size()) {
    判断[i, j]是while 满足条件否满足条件
    while (满足条件) {
        不断更新结果(注意在while内更新！)
        i += 1; （最大程度的压缩i，使得滑窗尽可能的小）
    }
    j += 1;
}

while (end < nums.size()){
	ans += nums[end];   // 条件递进
    while (ans >= target){   // 不满足情况
    	len = min(len, end-start+1);  // 更新值
        ans-=nums[start++];
    }
    end++;
}

最大滑窗模板：给定数组 nums，定义滑窗的左右边界 i, j，求满足某个条件的滑窗的最大长度。

while (j < nums.size()) {
    判断[i, j]是while 满足条件否满足条件
    while (不满足条件) {
        i += 1; （最保守的压缩i，一旦满足条件了就退出压缩i的过程，使得滑窗尽可能的大）
    }
    不断更新结果(注意在while外更新！)
    j += 1;
}

while (end < fruits.size()) {
	basket[fruits[end]]++;  // 条件递进
    while (basket.size() > 2) {  // 不满足情况
    	int t = fruits[start++];
        if (--basket[t] == 0) {
        	basket.erase(t);
        }
    }
    // 更新结果值
    if (end - start + 1 > maxlen) maxlen = end - start + 1;
    	end++;
}

最大滑窗是在迭代右移右边界的过程中更新结果，而最小滑窗是在迭代右移左边界的过程中更新结果。

相关题目推荐

904 水果成篮

你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果种类 。
你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：
你只有两个篮子，并且每个篮子只能装单一类型的水果。每个篮子能够装的水果总量没有限制。
你可以选择任意一棵树开始采摘，你必须从每棵树（包括开始采摘的树）上恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。
给你一个整数数组 fruits ，返回你可以收集的水果的 最大数目。

示例 1：
输入：fruits = [1,2,1]
输出：3
解释：可以采摘全部 3 棵树。

示例 2：
输入：fruits = [0,1,2,2]
输出：3
解释：可以采摘 [1,2,2] 这三棵树。
如果从第一棵树开始采摘，则只能采摘 [0,1] 这两棵树。

示例 3：
输入：fruits = [1,2,3,2,2]
输出：4
解释：可以采摘 [2,3,2,2] 这四棵树。
如果从第一棵树开始采摘，则只能采摘 [1,2] 这两棵树。

示例 4：
输入：fruits = [3,3,3,1,2,1,1,2,3,3,4]
输出：5
解释：可以采摘 [1,2,1,1,2] 这五棵树。
 

提示：

1 <= fruits.length <= 10^5
0 <= fruits[i] < fruits.length

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        //转化问题为：求只包含两种元素的最长连续子序列
        int i = 0; // 滑动窗口起始位置
        int j = 0; //滑动窗口终止位置
        int subLength = 0; // 子序列的长度
        int count = 0; //篮子中的水果种类数
        int n = fruits.size();

        unordered_map<int, int> basket; //创建篮子

        for(; j < n; j++) {
            if(basket[fruits[j]] == 0) {
                count++;
            }
        //因为value是int属性、初始值为0，相当于将fruits的元素作为key依次放入哈希表basket中，并更新对应value（表示该key的出现次数）
        basket[fruits[j]]++;
        //如果篮子中的水果数目超过两种，则需要移动左边界，对应从子序列中删去水果的value要减一
        for(; count > 2; i++) {
            basket[fruits[i]]--;
            //若对应水果key的value变为0，说明篮子里已经没有这种水果了，水果种类要对应变化
            if (basket[fruits[i]] == 0) {
                    count--;
            }
        }
        //在第二个for循环结束后，篮子中的水果一定满足题意要求，此时更新子序列长度
        subLength = max(subLength, j - i + 1);
        }
    return subLength;
    }
};

76 最小覆盖子串

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

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

示例 1：
输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"
解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。
示例 2：
输入：s = "a", t = "a"
输出："a"
解释：整个字符串 s 是最小覆盖子串。
示例 3:
输入: s = "a", t = "aa"
输出: ""
解释: t 中两个字符 'a' 均应包含在 s 的子串中，
因此没有符合条件的子字符串，返回空字符串。
 
提示：
m == s.length
n == t.length
1 <= m, n <= 10^5
s 和 t 由英文字母组成
 
进阶：你能设计一个在 o(m+n) 时间内解决此问题的算法吗？

滑动窗口的思想：
用i,j表示滑动窗口的左边界和右边界，通过改变i,j来扩展和收缩滑动窗口，可以想象成一个窗口在字符串上游走，当这个窗口包含的元素满足条件，即包含字符串T的所有元素，记录下这个滑动窗口的长度j-i+1，这些长度中的最小值就是要求的结果。

(1) 不断增加j使滑动窗口增大，直到窗口包含了T的所有元素

(2) 断增加i使滑动窗口缩小，因为是要求最小字串，所以将不必要的元素排除在外，使长度减小，直到碰到一个必须包含的元素，这个时候不能再扔了，再扔就不满足条件了，记录此时滑动窗口的长度，并保存最小值。

(3) 让i再增加一个位置，这个时候滑动窗口肯定不满足条件了，那么继续从步骤一开始执行，寻找新的满足条件的滑动窗口，如此反复，直到j超出了字符串S范围。

如何判断滑动窗口包含了T的所有元素？

我们用一个字典need来表示当前滑动窗口中需要的各元素的数量，一开始滑动窗口为空，用T中各元素来初始化这个need，当滑动窗口扩展或者收缩的时候，去维护这个need字典，例如当滑动窗口包含某个元素，我们就让need中这个元素的数量减1，代表所需元素减少了1个；当滑动窗口移除某个元素，就让need中这个元素的数量加1。
记住一点：need始终记录着当前滑动窗口下，我们还需要的元素数量，我们在改变i,j时，需同步维护need。
值得注意的是，只要某个元素包含在滑动窗口中，我们就会在need中存储这个元素的数量，如果某个元素存储的是负数代表这个元素是多余的。比如当need等于{‘A’:-2,‘C’:1}时，表示当前滑动窗口中，我们有2个A是多余的，同时还需要1个C。这么做的目的就是为了步骤二中，排除不必要的元素，数量为负的就是不必要的元素，而数量为0表示刚刚好。
回到问题中来，那么如何判断滑动窗口包含了T的所有元素？结论就是当need中所有元素的数量都小于等于0时，表示当前滑动窗口不再需要任何元素。

优化
如果每次判断滑动窗口是否包含了T的所有元素，都去遍历need看是否所有元素数量都小于等于0，这个会耗费
O(k)的时间复杂度，k代表字典长度，最坏情况下，k可能等于len(S)。
其实这个是可以避免的，我们可以维护一个额外的变量needCnt来记录所需元素的总数量，当我们碰到一个所需元素c，不仅need[c]的数量减少1，同时needCnt也要减少1，这样我们通过needCnt就可以知道是否满足条件，而无需遍历字典了。
前面也提到过，need记录了遍历到的所有元素，而只有need[c]>0大于0时，代表c就是所需元素

class Solution {
public:
    string minWindow(string s, string t) {
        if(s.size() < t.size()) {
            return "";
        }
        if(s.size() == 0 && t.size() == 0) {
            return s[0] == t[0] ? s : "";
        }
        //哈希表打表
        vector<int> cnt(128,0);
        int needCount = t.size(); //needCount统计所需字符数量
        for(char c : t) {
            cnt[c]++;
        }
        //不需要的全部变为INT_MIN
        for(int i = 0; i < cnt.size(); i++){
            if(cnt[i] == 0) {
                cnt[i] = INT_MIN;
            }
            
        }
        int right = 0; //窗口的右边界
        int size = INT_MAX; //目标字符串的最小长度
        int start = 0; //窗口的左边界,出发点

        for(int left = 0; left < s.size(); left++) {
            //所需字符串数量不够，从窗口一直右移
            while(right < s.size() && needCount > 0) {
                //对于无关字符直接不去管
                if(cnt[s[right]] != INT_MIN) {
                    //对于缺的字符，needcount需要减
                    if(cnt[s[right]] > 0){
                        needCount--;
                    }
                    //对于不缺的但是是目标字符仍需要减1
                    cnt[s[right]]--;
                }
                right++;
            }
            //更新目标起点和长度
            if(needCount == 0 && right - left < size){
                size = right - left;
                start = left;
            }
            //窗口左侧右移1位
            //排除无关字符
            if(cnt[s[left]] != INT_MIN){
                //等于0表示右移后会缺少
                if(cnt[s[left]] == 0){
                    needCount++;
                }
                //小于0的表示还多出来有富余，只需数量减少
                cnt[s[left]]++;
            }
        }
        return size < INT_MAX ? s.substr(start,size) : "";
    }
};