滑动窗口
所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。
滑动窗口的精妙之处在于根据当前子序列和的大小情况，不断调节子序列的起始位置。将时间复杂度降为O(n)。
长度最小的子数组
示例 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
s=7， 数组是 2，3，1，2，4，3，来看一下查找的过程：
解题的关键在于 窗口的起始位置如何移动，如图所示：
c++实现
class Solution {
public:
int minSubArrayLen(int target, vector<int>& nums) {
int result = INT32_MAX;
int sum = 0;// 滑动窗口数值之和
int sublength = 0;// 滑动窗口的长度
int i=0;// 滑动窗口起始位置
for (int j=0;j<nums.size();j++){
sum += nums[j];
// 注意这里使用while，每次更新 i（起始位置），并不断比较子序列是否符合条件
while(sum>=target){
sublength = j-i+1;// 取子序列的长度
result = result<sublength?result:sublength;
sum -= nums[i++];// 这里体现出滑动窗口的精髓之处，不断变更i（子序列的起始位置）
}
}
// 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
return result == INT32_MAX ? 0 : result;
}
};
go实现
func minSubArrayLen(target int, nums []int) int {
i,sum,sublength := 0,0,0
length := len(nums)
result := length+1// 初始化返回长度为l+1，目的是为了判断“不存在符合条件的子数组，返回0”的情况
for j:=0;j<length;j++ {
sum += nums[j]
for sum>=target {
sublength = j-i+1
if sublength < result {//go语言没有三目运算符
result = sublength
}
sum -= nums[i]
i++
}
}
if result == length+1{
return 0
}
return result
}
剑指 Offer II 008. 和大于等于 target 的最短子数组
给定一个含有 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.定义两个指针start和end分别表示子数组（滑动窗口窗口）的开始位置和结束位置，维护变量sum存储子数组中的元素和（即从 nums[start]到nums[end] 的元素和）。
2.初始状态下，start 和end 都指向下标 0，sum 的值为 0。
3.每一轮迭代，将 nums[end] 加到 sum，如果sum≥s，则更新子数组的最小长度（此时子数组的长度是 end−start+1），然后将 nums[start] 从 sum 中减去并将start 右移，直到 sum<s，在此过程中同样更新子数组的最小长度。在每一轮迭代的最后，将end 右移。
go
func minSubArrayLen(target int, nums []int) int {
//判空
if len(nums) == 0 {
return 0
}
ans := math.MaxInt32
start,sum,sublength := 0,0,0
for end := 0;end<len(nums);end++ {
sum += nums[end]
for sum>=target{
sublength = end-start+1
if ans > sublength {
ans = sublength
}
//ans = min(ans,sublength)
sum -= nums[start]
start++
}
}
if ans == math.MaxInt32{
return 0
}
return ans
}
// func min(x,y int) int {
// if x < y {
// return x
// }
// return y
// }
c++
class Solution {
public:
int minSubArrayLen(int s, vector<int>& nums) {
int n = nums.size();
if (n == 0) {
return 0;
}
int ans = INT_MAX;
int start = 0, end = 0;
int sum = 0;
while (end < n) {
sum += nums[end];
while (sum >= s) {
ans = min(ans, end - start + 1);
sum -= nums[start];
start++;
}
end++;
}
return ans == INT_MAX ? 0 : ans;
}
};
复杂度分析
时间复杂度：O(n)，其中 n 是数组的长度。指针start和end最多各移动n次。
空间复杂度：O(1)。
剑指 Offer II 009. 乘积小于 K 的子数组
给定一个正整数数组 nums和整数 k ，请找出该数组内乘积小于 k 的连续的子数组的个数。
示例 1:
输入: nums = [10,5,2,6], k = 100
输出: 8
解释: 8 个乘积小于 100 的子数组分别为: [10], [5], [2], [6], [10,5], [5,2], [2,6], [5,2,6]。
需要注意的是 [10,5,2] 并不是乘积小于100的子数组。
示例 2:
输入: nums = [1,2,3], k = 0
输出: 0
c++
class Solution {
public:
int numSubarrayProductLessThanK(vector<int>& nums, int k) {
int left=0,right=0;
int res=0, tmp=1;
for(;right<nums.size(); ++right){
tmp*=nums[right];
while(left<=right && tmp>=k){
tmp/=nums[left];
left++;
}
//因为连续的子数组的个数，所以每次计数：（自身+与之前数字搭配）= 1+（right-left）
if (right>=left)
res += right-left+1;
}
return res;
}
};
go
func numSubarrayProductLessThanK(nums []int, k int) int {
left := 0
res := 1
count := 0
for right:=0;right<len(nums);right++ {
res *= nums[right]
for left<=right && res >= k {
res /= nums[left]
left++
}
if right >= left {
count += right - left + 1
}
}
return count
}
904. 水果成篮
你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果 种类 。
你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：
你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。
示例 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] 这五棵树。
go实现
func totalFruit(fruits []int) int {
hashmap := map[int]int{} //建立一个哈希表，记录已经在篮子里的水果个数(区间内元素的种类个数)
l,n,res := 0,len(fruits),0
for r:=0;r<n;r++ {//r指针遍历数组
hashmap[fruits[r]]++ //我们想得到以r为结尾的区间，所以i必须取到
for l<=r&&len(hashmap)==3 {//当哈希表的长度是3的时候表示区间内元素的种类有3个，不符合题意
hashmap[fruits[l]]-- //l指针向右移动，将l指向的水果数目-1
if hashmap[fruits[l]]==0 {//当hashMap[fruits[l]] == 0时表示篮子里没有这种水果了，直接delete
delete(hashmap,fruits[l])
}
l++
}
//每次循环之后，我们都得到以r为结尾的符合题意的最长区间
//通过if选择每次的结果，得到最终的最优解
if res<r-l+1 {
res = r-l+1
}
}
return res
}
c++实现
class Solution {
public:
int totalFruit(vector<int>& fruits) {
int left = 0;
map<int,int> mapp;
int res = 0;
for (int right = 0;right<fruits.size();right++){
mapp[fruits[right]]++;
while(left<=right && mapp.size()==3) {
mapp[fruits[left]]--;
if (mapp[fruits[left]]==0){
//c++ map删除用 rease() 添加:insert() 求长度:size()
mapp.erase(fruits[left]);
}
left++;
}
if(res<right-left+1){
res = right-left+1;
}
}
return res;
}
};
