数组篇——双指针法(leetcode209)滑动窗口法(leetcode904）

 1.[leetcode209]

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

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

时间复杂度：O(n)

空间复杂度：O(n)

原理：新数组最大元素一定由原数组最左端或最右端元素平方得到，于是在两端比较后得到新数组最后一个元素，然后移动左右指针继续比较

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
      //双指针法：新数组的最大值一定在两端
      int i=0,j=nums.size()-1,k=j;
      vector<int> result(j+1,0);
      while(i<=j)
      {
          if(nums[i]*nums[i]>nums[j]*nums[j]) {
              result[k--]=nums[i]*nums[i];
              i++;
          }
          else {
             result[k--]=nums[j]*nums[j]; 
              j--;
          } 
      }
      return result;
    }
};

2. [leetcode 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] 这两棵树。

解法一：个人无脑写法，原理很简单，当种类超过2时向左压缩区间 

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        int type1=-1,type2=-1; //两种篮子对应的水果类型
        int type1_num=0,type2_num=0; //两种水果类型当前装的水果数量
        int low=0,high; //设置滑动窗口的左右边界
        int ans=0;
        //移动窗口右边界(摘果子)
        for(high=0;high<fruits.size();high++)
        {
            //一号篮装水果
            if(fruits[high]==type1) {
                type1_num++;
            }
            //二号篮装水果
            else if(fruits[high]==type2) {
                type2_num++;
            }
            else{
            //下讨论水果种类与篮中水果不同情况
            //如果两个果篮都是空的,一号篮装上水果
            if(type1==-1&&type2==-1){
            type1=fruits[high];
            type1_num++;
            }
            //如果一号果篮不空并且二号果篮空，二号篮装上水果
            else if(type2==-1) {
                type2=fruits[high];
                type2_num++;
            } 
             //如果二号果篮不空并且一号果篮空，一号篮装上水果
            else if(type1==-1) {
                type1=fruits[high];
                type1_num++;
            } 
            //如果新出现第三类水果，则记录当前子数组长度并移动左窗口压缩区间
            else{
                if(high-low>ans)
                ans=high-low;
                //当两个篮子都不为空时继续压缩
                while(type1_num!=0&&type2_num!=0)
                {
                      if(fruits[low]==type1) type1_num--;
                      else type2_num--;
                      low++;   
                }
                //把新水果装入空出的篮子中
                if(type1_num==0){
                    type1=fruits[high];
                    type1_num++;
                }
                else {
                    type2=fruits[high];
                    type2_num++;
                }

            }

            }

        }
    //别忘了最后答案更新
         ans=high-low>ans?high-low:ans;
        return ans;
    }
};

 下面是官方使用哈希表的答案

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)//水果种类大于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;
    }
};

时间复杂度：O(n)

空间复杂度：O(1)哈希表中最多会有三个键值对，可以看成使用了常数级别的空间。