[代码随想录]数组--长度最小子数组

长度最小子数组

解决方法

1.暴力解决：两个for循环，然后不断的寻找符合条件的子序列

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

2.滑动窗口：

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

就用一个for循环解决

举例，s=7， 数组是 2，3，1，2，4，3，来看一下查找的过程：

滑动窗口也可以理解为双指针法的一种

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

1.窗口内是什么？
2.如何移动窗口的起始位置？
3.如何移动窗口的结束位置？

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

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

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

解题的关键在于 窗口的起始位置如何移动

滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置

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

相关例题

209. 长度最小的子数组

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

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

1.自己思路

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int solwIndex = 0;
        int minIndex = 0, maxIndex = nums.size() - 1;
        int sum = 0;
        for(int fastIndex = 0;fastIndex < nums.size();){
            if(nums[fastIndex] >= target){
                return 1;
            }
            else if(sum + nums[fastIndex] >= target){
                if((fastIndex - solwIndex) < (maxIndex - minIndex)){
                    minIndex = solwIndex;
                    maxIndex = fastIndex;
                }
                else if((sum - nums[solwIndex]) >= target){
                    minIndex++;
                }
                sum = sum - nums[solwIndex];
                solwIndex++;
            }
            else if(solwIndex == 0 && fastIndex == nums.size() -1){
                return 0;
            }
            else{
                sum = sum + nums[fastIndex];
                fastIndex++;
            }
        }
        return maxIndex - minIndex + 1;
    }
};

2.暴力解决

两个for循环

3.滑动窗口

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int leftIndex = 0;
        int arrLength = 0;
        int sum = 0;
        int result = INT32_MAX;
        for(int rightIndex = 0;rightIndex < nums.size();rightIndex++){
            sum += nums[rightIndex];
            while(sum >= target){
                arrLength = rightIndex - leftIndex + 1;
                result = result < arrLength ? result :arrLength;
                sum -= nums[leftIndex++];//关键
            }
        }
        return result == INT32_MAX ? 0: result;
    }
};

904. 水果成篮

你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果 种类 。

你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：

• 你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
• 你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
• 一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。

给你一个整数数组 fruits ，返回你可以收集的水果的 最大 数目。

1.自己用滑动窗口暴力解决，没用map和set

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        int leftIndex = 0;
        int arrFruit = 0;//当前两种水果的数组长度
        int one = fruits[leftIndex],two = -10;//记录两个水果种类
        int result = 1;
        int i = 0,j = 0;//记录要删除的一种水果在当前数组中最后一个位置下标
        for(int rightIndex = 1;rightIndex < fruits.size();rightIndex++){
            if(fruits[rightIndex] != one && two == -10){
                two = fruits[rightIndex];
                j = rightIndex;
                arrFruit = rightIndex - leftIndex + 1;//记录当前两种水果数组长度
                result = (result > arrFruit) ? result : arrFruit;//选择最长的
            }
            else if(fruits[rightIndex] == one || fruits[rightIndex] == two){
                i = (fruits[rightIndex] == one) ? rightIndex : i;//第一种水果在此数组中最后一个位置下标
                j = (fruits[rightIndex] == two) ? rightIndex : j;//同上
                arrFruit = rightIndex - leftIndex + 1;//记录当前两种水果数组长度
                result = (result > arrFruit) ? result : arrFruit;//选择最长的
            }
            else if(fruits[rightIndex] != one && fruits[rightIndex] != two){ 
                leftIndex = (i > j) ? (j + 1): (i + 1);//选择小的下标水果删除
                one = (i > j) ? one : two;
                two = fruits[rightIndex];
                i = (i > j) ? i : j;
                j = rightIndex;
                arrFruit = rightIndex - leftIndex;//记录当前两种水果数组长度
                result = (result > arrFruit) ? result : arrFruit;//选择最长的
            }
        }
        return result;
    }
};

2.哈希表+滑动窗口

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        unordered_map<int, int> fruitNums;
        int result = 0;
        for (int leftIndex = 0, rightIndex  = 0; rightIndex  < fruits.size(); rightIndex++) {
            fruitNums[fruits[rightIndex]]++;//该key值索引的数据加一
            while (fruitNums.size() > 2) {
                fruitNums[fruits[leftIndex]]--;//从左边开始两种水果key值索引的数据每次遇到就减一
                if (fruitNums[fruits[leftIndex]] == 0) {//这两种水果靠近最右边的种类保留，并且保留连续的
                    fruitNums.erase(fruits[leftIndex]);
                }
                leftIndex++;
            }
            result = result > (rightIndex - leftIndex + 1) ? result : (rightIndex - leftIndex + 1);
        }
        return result;
    }
};

*76. 最小覆盖子串

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

1.滑动窗口

class Solution {
public:
    string minWindow(string s, string t) {
        unordered_map<char,int> tMap;
        unordered_map<char,int> window;
        int count = 0 ;//记录window中含有t中字符的个数
        string result = "";
        for(int i = 0;i < t.size();i++){
            tMap[t[i]]++; 
        }
        for(int left = 0, right = 0;right < s.size();right++){
            window[s[right]]++;
            if(window[s[right]] <= tMap[s[right]]){
                count++;
            }
            while(window[s[left]] > tMap[s[left]]){//将无用字符删除或将window中最左边重复与中间重复字符删除
                window[s[left]]--;
                left++;
            }
            if(count == t.size() && result.empty()){//第一次给result一个初始字符串
                result = s.substr(left,right - left + 1);
            }
            else if(count == t.size() && result.size() > (right - left + 1)){//后面result比第一次小就更新
                result = s.substr(left,right - left + 1);
            }
        }
         return result;
    }  
};