数组刷题笔记4：长度最小的子数组
长度最小的子数组
209. 长度最小的子数组
给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。
方法1：暴力解法
-
思路：使用两个for循环，不断寻找符合条件的子序列。
-
复杂度：
- 时间复杂度：O(N^2)，两个for循环
- 空间复杂度：O(1)
方法2：滑动窗口
- 思路：
- 窗口是满足大小的长度最小的连续子数组
- 当窗口值大于s，起点指针移动
- 窗口的结束位置是遍历数组的指针，窗口的起始位置为数组的起始位置
- 复杂度：
- 时间复杂度：O(N)，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被被操作两次，所以时间复杂度是 2 × n 也就是O(n)
- 空间复杂度：O(1)
class Solution {
public int minSubArrayLen(int target, int[] nums) {
int n = nums.length;
int result = n + 1;//设置为大于数组长度
int sum = 0; //滑动窗口内数组的和
int i = 0; //起点指针起始位置
int subLength = 0; //滑动窗口的长度
for (int j = 0; j < n; j++) {
sum += nums[j];
//如果和大于目标，开始移动起点位置
while (sum >= target) {
subLength = j - i + 1; //计算窗口长度
result = result < subLength ? result : subLength; //对比修改当前的窗口长度
sum -= nums[i++]; //移动起点，修改窗口和
}
}
//判断结果有没有改变，如果没有，不存在该改变长度的子数组，返回0；有则返回结果
return result == n + 1 ? 0 : result;
}
}
904. 水果成篮
你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果 种类 。
你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：
- 你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
- 你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
- 一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。
给你一个整数数组 fruits ，返回你可以收集的水果的 最大 数目。
滑动窗口法（思路简单，比较暴力）
- 设置n1, n2为数组最开始两个不重复的数
- 滑动到为不n1 n2的数，记录上一个窗口长度，进行对比
- 重新赋值n1为窗口尾部指向的前一个数（上一次窗口中的其中一个数），n2为当前窗口尾部指向的数（新数）
- 将起始指针从结束指针向前遍历为第一个n1的位置
- 继续滑动窗口尾部，重复操作
- 结尾没改变时没进入循环，最后计算一次窗口长度
class Solution {
public int totalFruit(int[] fruits) {
//使用滑动窗口找最长不重复的两个数字
int n = fruits.length;
if (n <= 2) return n; //长度小于2时，直接返回结果
int result = 2; //结果
int i = 0; //起始指针
int subLength = 0; //滑动窗口的长度
int n1 = fruits[0]; //设置两个篮子里的数
//给n2赋值为与第一个数不同的第一个数
int n2 = 0;
for (int j = 0; j < n; j++) {
if (fruits[j] != n1) {
n2 = fruits[j];
break;
}
}
//开始滑动窗口
//滑动到为不n1 n2的数，记录上一个窗口长度，进行对比
//重新赋值n1为窗口尾部指向的前一个数（上一次窗口中的其中一个数），n2为当前窗口尾部指向的数（新数）
//将起始指针从结束指针向前遍历为第一个n1的位置
//继续滑动窗口尾部，重复操作
for (int j = 0; j < n; j++) {
while ((fruits[j] != n1) && (fruits[j] != n2)) {
subLength = j - i; //此时j指向下一个不连续的元素，因此不需要+1
result = result > subLength ? result : subLength; //改变长度
n1 = fruits[j - 1]; //重新赋值n1为不同数的前一个数
n2 = fruits[j]; //重新赋值n2为不同的数
//将i向前遍历移动到第一个n1值的位置
i = j - 1;
while (fruits[i - 1] == fruits[i]) {
i--;
}
}
}
//结尾没改变时没进入循环，最后计算一次窗口长度
subLength = n - i; //数组长度为末尾j指向的下一个元素，不需要再+1
result = result > subLength ? result : subLength;
return result;
}
}
滑动窗口（计算水果种类，出现频次）
- 思路：滑动窗口系列中的计数问题，freq数组记录现在窗口中两种水果的数目，count记录现在窗口中有多少种不同的水果，如果count<=2，那么right指针可以一直向右移动，直到count>2,当count>2时，说明窗口中的水果种类超过2，为了减少水果种类，left指针就要向右移动，移动的同时还要更新freq数组，最后取最大值即可。
class Solution {
public int totalFruit(int[] fruits) {
int n = fruits.length;
if (n <= 2) return n;
int total = 2;
int left = 0;
int count = 0; // 计算篮中种类数
int[] fruitFrequence = new int[n]; // 计算篮中每种水果出现的次数。 因为提示中说明了水果的种类数是有限的 0 <= fruits[i] < fruits.length
for (int right = 0; right < n; right++) {
fruitFrequence[fruits[right]] += 1; // 入篮
if (fruitFrequence[fruits[right]] == 1) count+=1; //等于1说明第一次入篮，count需要加1
while (count > 2) { // 篮中超过两种水果
fruitFrequence[fruits[left]] -= 1; // 因为下边还要使用left下标，所以先不要移动
if (fruitFrequence[fruits[left]] == 0) count-=1; // 等于0说明篮中已经没有fruits[left]水果，count减1
left += 1; // 移动left
}
total = Math.max(total, right - left + 1); // 取窗口最大值
}
return total;
}
}
76. 最小覆盖子串（困难）
给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。
注意：
对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
如果 s 中存在这样的子串，我们保证它是唯一的答案。
滑动窗口法（数组）
- 右指针移动，直到包含t内的所有元素
- 计算长度和起点
- 左指针移动，如果有更小的区间更新长度和起点
- 直到区间不包含t，移动右指针，重复以上步骤
理解：
在遍历字符串的过程中，非目标字符的数量会被减到-1，因此增加count的计数。
当遍历到目标字符时，目标字符原本为0，计数器count+1，在执行后字符对应的值大于0，在进入下一次循环时，值减为一，并减少计数器的值，从而进入窗口的循环。
class Solution {
public String minWindow(String s, String t) {
//右指针移动，直到包含t内的所有元素
//计算长度和起点
//左指针移动，如果有更小的区间更新长度和起点
//直到区间不包含t，移动右指针，重复以上步骤
//如果s的长度小于t的长度，那s必然无法包含t的所有元素
//如果s与t相等，那结果为s或t
if (s.length() < t.length()) {
return "";
} else if (s.equals(t)) {
return s;
}
int left = 0; //左指针
int right = 0; //右指针
int count = t.length(); //记录未包含元素个数
int windowLength = s.length() + 1; //窗口长度
int start = 0; //窗口起点
//记录t中各个元素个数的数组（由英文字母组成，因此由字符所对应的数字的下标进行计数
int[] map = new int[128];
for (char c : t.toCharArray()) map[c]++;
while (right < s.length()) {
if (map[s.charAt(right++)]-- > 0) {
count--;
}
while (count == 0) {
if (right - left < windowLength) {
start = left;
windowLength = right - left;
}
if (map[s.charAt(left++)]++ == 0) {
count++;
}
}
}
if (windowLength != s.length() + 1) {
return s.substring(start, start + windowLength);
}
return "";
}
}
滑动窗口法（Map）
用map记录字符和字符数量，用字符数量验证是否符合要求
class Solution {
public String minWindow(String s, String t) {
//右指针移动，直到包含t内的所有元素
//计算长度和起点
//左指针移动，如果有更小的区间更新长度和起点
//直到区间不包含t，移动右指针，重复以上步骤
//如果s的长度小于t的长度，那s必然无法包含t的所有元素
//如果s与t相等，那结果为s或t
if (s.length() < t.length()) {
return "";
} else if (s.equals(t)) {
return s;
}
int left = 0; //左指针
int right = 0; //右指针
int count = t.length(); //记录未包含元素个数
int windowLength = s.length() + 1; //窗口长度
int start = 0; //窗口起点
//获得所需的t的字符
Map<Character, Integer> map = new HashMap<>();
for (char c : t.toCharArray()) {
map.put(c, map.getOrDefault(c, 0) + 1);
}
while (right < s.length()) {
//如果窗口中包含t中的字符，值-1
char rightChar = s.charAt(right);
if (map.containsKey(rightChar)) {
map.put(rightChar,map.get(rightChar) - 1);
}
right++;
//当满足t的字符串，进行窗口的长度计算
while (check(map)) {
if (right - left < windowLength) {
windowLength = right - left;
start = left;
}
//移除左边的元素
char leftChar = s.charAt(left);
if (map.containsKey(leftChar)) {
map.put(leftChar,map.get(leftChar) + 1);
}
left++;
}
}
return windowLength == s.length() + 1 ? "" : s.substring(start,start + windowLength);
}
//用value判断是否包含所有字符，所有value<=0时包含
boolean check(Map<Character, Integer> map) {
for (int value : map.values()) {
if (value > 0) {
return false;
}
}
return true;
}
}
